Circular Buffers D 1 D.1 INTRODUCTION D.2 DECLARING CIRCULAR BUFFERS D.3 ACCESSING CIRCULAR BUFFERS

Transcription

1 Circular Buffers D D.1 INTRODUCTION A circular buffer is an array whose pointer wraps around to the first member of the array when the pointer is incremented past the last member. The file macros.h contains macros for using circular buffers in C. Refer to the ADSP-2106x SHARC User s Manual or ADSP User s Manual for a description of circular buffers. Also refer to Chapters 3 and 4 of this manual for descriptions of the C runtime environment and interface to assembly language. D.2 DECLARING CIRCULAR BUFFERS These macros are used to declare the circular buffer pointer and initialize registers: CIRCULAR_BUFFER(type,dag-number,) BASE(name) LENGTH(name) The pointer to the circular buffer,, must be global and also the CIRCULAR_BUFFER macro must be used in every C module that is used in the application. D.3 ACCESSING CIRCULAR BUFFERS These macros are used to access the circular buffer: CIRC_READ(, step, variable, memory) CIRC_WRITE(, step, variable, memory) CIRC_MODIFY (, step) D 1

2 D Circular Buffers D.4 CIRCULAR_BUFFER This macro creates three variables which are associated with three ADSP-21xxx registers. CIRCULAR_BUFFER(type,dag-number,) type dag-number The type (e.g. float or int ) of the array to be used as a circular buffer. The number of the data address generator register (DAG) to be used. For example, if DAG1 is used, the registers i1, b1, and l1 will be used. Available DAGs are: 0,1,2,3, and 5. The pointer to the array/circular buffer. For example: CIRCULAR_BUFFER(int,1,echo); results in: register int * echo asm( i1 ); register int _length_echo asm( l1 ); register int _base_echo asm( b1 ); D.5 BASE BASE initializes the B register to the first location of the circular buffer. Before using the BASE and LENGTH macros, an array should be declared. This array will be used as a circular buffer. For example, float circbuf[16]; BASE()=array_name; array_name The pointer to the array/circular buffer that was used in the CIRCULAR_BUFFER macro. The name of the array which will be used as a circular buffer. D 2

3 Circular Buffers D D.6 LENGTH Length initializes the L register to the size of the circular buffer. Before using the BASE and LENGTH macros, an array should be declared. This array will be used as a circular buffer. For example, float circbuf[16]; LENGTH()=length; length The pointer to the array/circular buffer that was used in the CIRCULAR_BUFFER macro. The size of the array to be used as a circular buffer. D.7 CIRC_READ Read the array/circular buffer location which is pointed to by and place the value in variable. Increment by step. CIRC_READ(, step, variable, memory ) step variable memory The pointer to the array/circular buffer. The step by which to postmodify the pointer. The variable in which the value read from the array/ circular buffer is stored. Data Memory (dm) D.8 CIRC_WRITE Write to the array/circular buffer location which is pointed to by from the value in variable. Increment by step. CIRC_WRITE(, step, variable, memory ) step variable memory The pointer to the array/circular buffer. The step to increment the pointer after the write. The variable holding the value to be written to the array/ circular buffer. Data Memory (dm) D 3

4 D Circular Buffers D.9 CIRC_MODIFY Modify the pointer to the array/circular buffer by step. Do not read or write from the array. CIRC_MODIFY(, step) The pointer to the array/circular buffer. step The step by which to modify the pointer. D.10 DEBUGGING CIRCULAR BUFFERS Since register variables are disabled by the -g switch, circular buffer assembly code will be much different than without the -g switch. Circular buffer operations when compiling with -g will be slower than without -g. D.11 CIRCULAR BUFFER EXAMPLE The following example demonstrates the use of circular buffers: /************************************************************************/ /* CIRCBUF.C */ /************************************************************************/ /* This is an echo program written entirely in C to be used */ /* with the ADSP EZ-LAB board. */ /* */ /* The echo program takes the talkthru program and adds a */ /* circular buffering scheme. The circular buffer is defined */ /* by the functions CIRCULAR_BUFFER, BASE, and LENGTH. The */ /* echo is performed by adding the current input to the oldest */ /* input. The amount of delay in the echo can be modified by */ /* changing the value of BUFF_LENGTH. */ /************************************************************************/ #include <21020.h> /* For the idle() command */ #include <signal.h> /* For the interrupt command */ #include <macros.h> /* For the CIRCULAR_BUFFER and segment functions */ #define BUFF_LENGTH 4000 CIRCULAR_BUFFER(float,1,echo); /* Define echo as 21k DAG1 reg i1 */ /* a DM pointer to a circular buffer */ D 4

5 Circular Buffers D volatile int in_port segment(hip_reg0); /* hip_reg0 and hip_reg2 are */ volatile int out_port segment(hip_reg2);/* used in architecture file */ void process_input(int); void main(void) { /* make this a variable length array. If emulator is stopped at main */ /* and _BUFF_LENGTH in dm window is modified, the delay of the echo */ /* is modified. Do not make BUFF_LENGTH greater than stack size! */ float data_buff[buff_length]; interrupt(sig_irq3, process_input); BASE(echo) = data_buff; /* Loads b1 and i1 with buff start adr */ LENGTH(echo) = BUFF_LENGTH; /* Loads L1 with the length of buffer */ /* As the array is filled, the nth location contains the newest value, */ /* while the nth+1 location contains the oldest value. */ while (1) { /* The echo sends the sum of the most */ float oldest,newest; /* recent value and the oldest value */ idle(); /* echo is pointing to the nth location after the interrupt routine. */ /* place the new value in variable newest. After the access, update */ /* the pointer by one to point at location n+1. */ CIRC_READ(echo,1,newest,dm); /* Now echo is pointing to n+1. Read the location and place value in */ /* variable oldest. Do not update the pointer, since it is now */ /* pointing to the new location for the interrupt handler */ CIRC_READ(echo,0,oldest,dm); } } /* add the oldest and most recent and send out on port */ out_port=oldest+newest; void process_input(int int_number) { /* The newest input value is written over the oldest value in the nth */ /* location and the pointer is not updated. */ /* A cast to float is necessary before writing in_port to *echo. */ CIRC_WRITE(echo, 0, (float)in_port, dm); } Listing D.1 Circular Buffer Example D 5

6 D Circular Buffers D 6