LAB 8: DATA HANDLING - BUFFERING

Transcription

1 EEM478 DSP HARDWARE 2013 LAB 8: DATA HANDLING - BUFFERING In this experiment, we will use two types of buffers to collect and process data frames. While collecting data in a buffer, we will implement processing of data at the same time. Two basic types of data collecting methods are double buffering and circular buffering each has pros and cons depending on the point of view. We will introduce these buffering types in two separate parts. PART 1: DOUBLE BUFFERING In this part, we will introduce double buffers to collect and process data frames. While collecting data in a buffer, we will operate on a second one. After processing is done, we will exchange the roles of the first and the second buffers. Double buffering scheme is a new concept for you, since you have processed a single data sample so far in the previous lab-works. This scheme requires synchronization between multiple tasks. Many real-time DSP applications must perform a number of seemingly unrelated functions at the same time, often in response to external events such as the availability of data or the presence of a control signal. Both the functions performed and when they are performed are important. These functions are called threads. Different systems define threads either narrowly or broadly. The term thread is defined broadly to include any independent stream of instructions executed by the DSP. A thread is a single point of control that can contain a subroutine, an interrupt service routine (ISR), or a function call. Real-time application programs are organized in a modular fashion - as opposed to a single, centralized polling loop, for example are easier to design, implement, and maintain. Algorithm for Double Buffering: The basic goal is to employ two tasks to calculate the energies of two buffers which are updated in a real-time hardware interrupt with the audio codec input samples. When first buffer becomes full, interrupt service routine will set a flag and switch to writing samples into the second buffer. The set triggers the awaiting task. While the task is calculating the energy of the filled buffer, interrupt system stores new coming samples into the second buffer. After the calculation of the energy, its value is printed as a result, and the task waits again for the first buffer to be full. When the second buffer becomes full, ISR will again set a flag that is waited (pended) by a second task which will calculate and print the energy of the second buffer in the same manner of that of the first task. These switching two buffers will continuously be filled by ISR function and energies will be calculated in tasks after switching occurs. Therefore double buffering is implemented continuously using this exchanging method. According to the Parseval s Theorem, energy E of N-samples-length discrete signal x can be calculated using the following formula: E = where x[n] is the time-domain signal and X[k] is the Discrete Fourier Transform of x. We will use the time-domain signal samples to calculate the energy.

2 PART-1 A. Lab Work for Double Buffering You will use the following code with your further modifications upon recommended instructions (green texts): #include <math.h> #include <stdio.h> #include "DSK6713_AIC23.h" // codec support //set sampling rate Uint32 fs=dsk6713_aic23_freq_8khz; #define DSK6713_AIC23_INPUT_MIC 0x0015 #define DSK6713_AIC23_INPUT_LINE 0x0011 Uint16 inputsource=dsk6713_aic23_input_mic; // select input #define SAMPLING_FREQ 8000 void task0(); // task for calculating energy of buffer0 void task1();// task for calculating energy of buffer1 float calculate_energy(short buffer_id); interrupt void c_int11(); Define a double buffer with following rows: #define BUF_SIZE 256 short buffer[2][buf_size]; // Double buffer short buf_id = 0; // Buffer ID for switching between double buffers short flag_buffer_full = 0; // Flag for informing main() that buffer is full float enx; short in_sample; // current input sample from codec short in_ptr = 0; // position index for writing to buffer void main() comm_intr(); flag_buffer_full = 0; while(1) if(flag_buffer_full == 1) // Wait until buffer is switched flag_buffer_full = 0; // reset the flag for next if(buf_id == 1) // buffer[0][] is full task0(); else if(buf_id == 0) // buffer[1][] is full task1();

3 Modify your interrupt function as following: interrupt void c_int11() in_sample = input_sample(); buffer[buf_id][in_ptr++]= in_sample; if(in_ptr == BUF_SIZE) in_ptr = 0; // reset index // TO DO: switch between buffers by toggling buf_id // TO DO: set the flag for filled buffer output_sample(in_sample); return; Define two tasks to calculate energies of buffers: void task0() enx = calculate_energy(0); // Print energy void task1() enx = calculate_energy(1); // Print energy Energy calculating function is defined as following. Add necessary code to compute the energy of only the corresponding part of buffer: float calculate_energy(int buffer_id) float energy = 0.0; // TO DO: operate on buffer[buf_id][] // and calculate its energy using Parseval's equation return energy; You will implement the energy calculation function of the code. Write the code using Parseval s energy calculation equation, and run your program. PART-1 B. After lab Discuss your results and observations.

4 PART 2: CIRCULAR BUFFERING AND OVERLAPPING BUFFERS In previous part, we used two separate buffers to collect and process data. Occasionally, this may not be an optimal solution due to several limitations or issues such as limited memory size or necessity to use shared data between consecutive processing times. In such cases, instead of using a couple of big-sized buffers, one can use four or more smaller-sized intersecting buffers for collecting and processing signal samples. A circular buffer method will be employed to handle the overlapping operation. This kind of operation will yield us to deal with real-time situations, since end of frames always impose some problems on the output signal. A frame can be defined as a part of data/signal that is operated or processed at once. In this case, the term frame is used to name 256 samples of data. Algorithm for Circular Buffering: Instead of two 256-sized buffers, we will use five 64-sized buffers. Flags and multiple tasks will be used to handle collecting and processing data in circular manner. The following illustration will help you to understand the idea. In the following text, qx refers to quarter buffer with ID:X. When q0 is being filled, the other four quarter-buffers will be processed as a frame in the order q1- q2 - q3 - q4. When q1 is being filled, the other four quarter-buffers will be processed as a frame in the order q2 - q3 - q4 - q0. When q2 is being filled, the other four quarter-buffers will be processed as a frame in the order q3 - q4 - q0 - q1. When q3 is being filled, the other four quarter-buffers will be processed as a frame in the order q4 - q0 - q1 - q2. When q4 is being filled, the other four quarter-buffers will be processed as a frame in the order q0 - q1 - q2 - q3.

5 PART-2 A. Lab Work In order to receive samples in circular manner, you need to modify the code above. Implement one global 320- sized buffer: #define FRAME_SIZE 256 #define BUF_SIZE 320 short buffer[buf_size], in_ptr = 0; short in_sample; short qbuf_id = 0; short flag_quarter_buffer_full = 0; // flag for task to check quarter buffer switching float enx; // energy of current frame void main() comm_intr(); flag_quarter_buffer_full = 0; while(1) if(flag_quarter_buffer_full == 1) // Wait until next quarter flag_quarter_buffer_full = 0; task(); You will use five 64-point quarters (a quarter here is ¼ of a 256-point frame). While storing new coming samples can be done in one quarter-buffer, other four quarter-buffers can be processed. Writing to buffer and reading from buffer should be handled in a circular manner. In other words, when the index comes to the end of buffer, it restarts from the beginning of buffer or vice versa. That means when you store a sample at buffer[buf_size- 1], you will go back to buffer[0] for the next sample. By the way, the same memory area is re-used without any need of extra buffers. While this is happening, the frame-processing operation is triggered at the beginning of every q-buffer (Say it at positions: 0, 64, 128, 192, and 256). You can use a position index (in_ptr) to detect where to store the new coming sample. The integer division, (int)(in_ptr/64) yields the current quarter-buffer s ID (0, 1, 2, 3, and 4). When interrupt routine switches to the next q-buffer to store samples, the recent four q-buffers (including the latest filled q-buffer) will be processed in the task. The interrupt service routine will handle the switching and trigger the task to calculate energy:

6 interrupt void c_int11() in_sample = input_sample(); buffer[in_ptr++] = in_sample; if(in_ptr % 64 == 0) // index is at trigger positions qbuf_id = (int)(in_ptr/64); // set current quarter buffer ID // TO DO: set the flag for task to start processing if(in_ptr == BUF_SIZE) in_ptr = 0; // reset index output_sample(in_sample); return; You will need a task to realize the explained scenario: void task() short frame_pos; // compute the frame start position for energy calc. // TO DO: set the start position for 256-sampled frame // using the qbuf_id value // calculate the energy of the frame. // and print out the value The energy calculation function is different from the version in Part-1 by means of circular index handling: float calculate_circular_energy(short frame_ptr) float energy = 0; // TO DO: operate on buffer starting from the frame_ptr in circular manner // and calculate its energy using Parseval's equation return energy; Make sure that the energy calculation operation can be performed in [64 * <sampling period>] seconds. (You can measure how long it takes to perform signal energy calculation using CCS tools remember 2 nd lab). PART-2 B. After Lab 1. What is the overlapping ratio of two consequtive 256-sampled frames in circular buffering scheme? In other words, how many samples are same/shared between two consequtive frames? 2. How would you implement DFT (discrete Fourier transform) on overlapping buffers? Search out for the equation of DFT and think about it. Can it be exectued in [64 * <sampling period>] seconds in c6713 DSK?