1    #define N 1024    /* Length of output buffers */
2    #define L N       /* Length of input data     */
3    #define logL 10   /* log base 2 of L          */
4    #define M 31      /* Compute 2*M+1 autocorrelation points */
5
6    /* #define M (L/2-1) */ /* Be sure to use ()'s in this case */
7                            /* or algebraic substitution bugs   */
8                            /* can be introduced                */
        
      

/* Compiler intrinsics for the TI compiler        */
/* and the Very Portable Optimizer (VPO) port     */
/* to TMS320C54X series DSPs                      */
/*                                                */
/* Use compile option -DVPO when using VPO        */
/*                                                */
/* Copyright September 2005 by Matt Kleffner      */
/* under the Creative Commons Attribution License */
/* Works with TMS320C55X series                   */

#ifndef INTRINSICS_H

#define INTRINSICS_H

#ifdef VPO

long int vpo_l_mul_ii(int w0, int w1);

/* fractional multiply without fractional mode (long result) */
#define _l_mul_fract_fb0_ii(w0,w1) \
         (vpo_l_mul_ii(w0,w1) << 1)

/* fractional multiply with fractional mode already on (long result) */
#define _l_mul_fract_fb1_ii(w0,w1) \
         (vpo_l_mul_ii(w0,w1))

/* fractional multiply without fractional mode (int result) */
#define _i_mul_fract_fb0_ii(w0,w1) \
         (vpo_l_mul_ii(w0,w1) >> 15)

/* fractional multiply with fractional mode already on (int result) */
#define _i_mul_fract_fb1_ii(w0,w1) \
         (vpo_l_mul_ii(w0,w1) >> 16)

#define _set_fract_bit() vpo_set_fract()
#define _reset_fract_bit() vpo_reset_fract()
#define _set_ovm_bit() vpo_set_ovm()
#define _reset_ovm_bit() vpo_reset_ovm()

#define _l_add_shiftl_li(w0,w1) (((int32)(w0))+(((int32)(int16)(w1))<<16) )
#define _l_sub_shiftl_li(w0,w1) (((int32)(w0))-(((int32)(int16)(w1))<<16) )

#else

/* fractional multiply without fractional mode (long result) */
#define _l_mul_fract_fb0_ii(w0,w1) \
         (((long int)w0 * (long int)w1) << 1)

/* fractional multiply with fractional mode already on (long result) */
#define _l_mul_fract_fb1_ii(w0,w1) \
         (((long int)w0 * (long int)w1))

/* fractional multiply without fractional mode (int result) */
#define _i_mul_fract_fb0_ii(w0,w1) \
         (((long int)w0 * (long int)w1) >> 15)

/* fractional multiply with fractional mode already on (int result) */
#define _i_mul_fract_fb1_ii(w0,w1) \
         (((long int)w0 * (long int)w1) >> 16)

#define _set_fract_bit() asm("	ssbx frct")
#define _reset_fract_bit() asm("	rsbx frct")
#define _set_ovm_bit() asm("	ssbx ovm")
#define _reset_ovm_bit() asm("	rsbx ovm")

#endif /* VPO */

#endif /* INTRINSICS_H */

        

// lab4b.c
// Uses PN generation, IIR filtering, and autocorrelation
// code by Matt Kleffner -9/2004
// Based on swi_process.c by Educational DSP

#include "dsk5510_dual3006cfg.h"
#include "dsk5510.h"
#include "swi_process.h"
#include "dsplib.h"

#include "lab4b.h"              /* Define N here in header file */

/* function defined in pn.c */
void rand_fillbuffer(void);

/* IIR values and buffers (declared in c_fft_given_iirc.asm) */
#define IIR_order 4
extern int scale;
extern int coef[IIR_order];
extern int state[IIR_order];

/* Pointer to state buffer location */
int iirptr;
extern unsigned int *iseed;            /* seed for rand_fillbuffer() and randbit() */

/* function defined in iirfilt.c */
void iirfilt(void);

/* function defined in autocorr.c */
void autocorr(void);

/* Function defined by c_fft_given_iirc.asm */
//void bit_rev_fft(void);

/* FFT data buffers (declared in c_fft_given_iirc.asm) */
extern int bit_rev_data[N*2];   /* Data output for bit-reverse function */
extern int fft_data[N*2];       /* In-place FFT input & Output array */

/* Our input/output buffers */
int autocorr_in[N];
int autocorr_out[N];

// all data processing should be done in SWI_ProcessBuffer

void SWI_ProcessBuffer()
{
	static unsigned int mbox_value = 0;
	short *psrc, *pdest;
	unsigned int i;

	mbox_value |= SWI_getmbox();

	// buffers are only processed when both transmit and receive are ready
	if((mbox_value & DMA_RECEIVE_DONE) && (mbox_value & DMA_TRANSMIT_DONE)) {
 		mbox_value = 0;

		// get buffer pointers
		psrc = receive_buffer[receive_buffer_to_process_index];
		pdest = transmit_buffer[transmit_buffer_to_fill_index];
		
		    /* First, transfer inputs and outputs */

	    for (i = 0; i < N; i++) 
	    {
    	    pdest[4*i] = autocorr_in[i];
        	pdest[4*i+1] = bit_rev_data[i*2] << 8;
		
        /* Some statements useful in debugging */
        /* pdest[4*i] = psrc[4*i+2]; */
        /* Be sure to comment out PN-sequence generation */
        /* when using the next two lines */
        //autocorr_in[i] = psrc[4i+2];
		
	    }
    	
    	/* Last, set the DC coefficient to -1 for a trigger pulse */
    	pdest[0] = -32768;

		/* Generate PN input */
    	rand_fillbuffer();
		
    	/* Filter input */
    	iirfilt();

    	/* Calculate autocorrelation */
    	autocorr();
	
	 	/* Transfer autocorr output to FFT input buffer */
    	for (i = 0; i < N; i++) {
        	fft_data[i*2] = autocorr_out[i];
        	fft_data[i*2+1] = 0;
    	}
 
		
		// Bit-reverse and compute FFT 
		cfft((DATA *)fft_data,N, SCALE);
		cbrev((DATA *)fft_data,(DATA *)bit_rev_data,N);
		
		
		 /* Done, wait for next time around! */
		receive_buffer_processed = 1; // flag receive buffer as processed
		transmit_buffer_filled = 1; // flag output buffer as full
	}
}


        

// lab4bmain.c
// based on main.c by Educational DSP
// Initializes autocorr_out, state, and iseed.
// Can be modified for optimization. 

#include "dsk5510_dual3006cfg.h"
#include "dsk5510.h"

#include <csl.h>
#include "lab4b.h"
#define IIR_order 4

extern int iirptr;
unsigned int *iseed;
extern int autocorr_out[N];
extern int state[IIR_order];

void init_DMA();

void main()
{
    int i;
 
	
    DSK5510_init();						// init BSL
    
    DSK5510_rset(DSK5510_MISC, 0x03);	// route McBSP0/1 to J3


	// Initialize autocorr_out to zero since some values will remain zero
	for (i = 0; i < N; ++i)
	{
		autocorr_out[i] = 0;
	}

	for ( i = 0; i < IIR_order; ++i)
		state[i] = 0;
    
    // Start McBSP0 I2S slave
    MCBSP_start(hMcbsp0, MCBSP_XMIT_START | MCBSP_RCV_START |
	MCBSP_SRGR_START | MCBSP_SRGR_FRAMESYNC, 220);
    
    // Start McBSP1 I2S master
    MCBSP_start(hMcbsp1, MCBSP_XMIT_START | MCBSP_RCV_START |
	MCBSP_SRGR_START | MCBSP_SRGR_FRAMESYNC, 220);
   
	init_DMA();							// configure DMA and interrupts

	*iseed = 1;	
	iirptr = 0;
   
    return;								// let DSP/BIOS scheduler take over
}

/* ECE420, Lab 4, Reference PN Generator Implementation (Non-Optimized) */
/* Matt Kleffner 08/04                                                  */
/* Original by Michael Frutiger 02/24/04                                */
/* Use governed by the Creative Commons Attribution License             */

#include "lab4b.h"

extern unsigned int *iseed;
extern int autocorr_in[N];

/* Returns as an integer a random bit, based on the 15 lowest significant
   bits in iseed (which is modified for the next call). */
int randbit()
{
   int newbit;
   /* XOR bits 15, 1 and 0 of iseed */
   newbit =  (*iseed >> 15) & 1 ^ (*iseed >> 1) & 1 ^ *iseed & 1;
   /* Leftshift the seed and put the result of the XOR's in bit 1. */
   *iseed=(*iseed << 1) | newbit;  
   return(newbit);
}

void rand_fillbuffer(void)
{
   int i;

   for (i = 0; i < N; ++i)
   {
      if (randbit()) autocorr_in[i] =  32767;
      else           autocorr_in[i] = -32767;
   }
}

        

/* Simple, unoptimized IIR filter (feedback only) */
/* for TMS320C54X series DSPs                     */
/* Copyright September 2005 by Matt Kleffner      */
/* under the Creative Commons Attribution License */
/* Works for TMS320C55X series as well			  */

#include "lab4b.h"
#include "intrinsics.h"

/* IIR values and buffers (declared in c_fft_given_iirc.asm) */
#define IIR_order 4
extern int scale;
extern int coef[IIR_order];
extern int state[IIR_order];

/* Arrays declared in main routine */
extern int autocorr_in[N];
extern int autocorr_out[N];

/* Pointer to state buffer location */
extern int iirptr;

void iirfilt()
{
    int i, j;

    _set_fract_bit();
    /* Filter PN input */
    for (i = 0; i < N; ++i)
    {
       int sum = 0;
       /* Calculate and sum all feedback terms except the "oldest" one */
       for (j = 0; j < (IIR_order-1); ++j)
       {
          sum += _i_mul_fract_fb1_ii(coef[j],state[iirptr]);
          /* Avoid usage of "modulo" routine */
          iirptr++;
          if (iirptr == IIR_order) iirptr = 0;
       }
       /* Calculate and sum oldest feedback term without incrementing iirptr */
       sum += _i_mul_fract_fb1_ii(coef[IIR_order-1],state[iirptr]);

       /* Calculate direct input contribution */
       sum += _i_mul_fract_fb1_ii(scale,autocorr_in[i]);
       autocorr_in[i] = sum;
       state[iirptr] = autocorr_in[i];
    }
    _reset_fract_bit();
}

       

/***********************************************************/
/* autocorr.c                                              */
/* Copyright August 2004 by Matt Kleffner                  */
/* under the Creative Commons Attribution License          */
/*                                                         */
/* Simple, unoptimized autocorrelation function            */
/* for ECE 420 (TMS320C54X series)                         */
/*                                                         */
/* #defines expected in lab4b.h                            */
/*    L: length of data in autocorr_in buffer              */
/*    N: length of data in autocorr_out buffer             */
/* logL: log base 2 of L (used for scaling output)         */
/*    M: Largest positive lag of autocorrelation desired   */
/*       (must be < L and < N/2)                           */
/*                                                         */
/* 16-bit-limited input/output (must be defined elsewhere) */
/*  autocorr_in: buffer for input data  (L pts)            */
/* autocorr_out: buffer for output data (N pts)            */
/*               N must be >= 2*M+1                        */
/*               assumed to be full of zeros at start      */
/*               output in zero-phase form                 */
/***********************************************************/
/* Works for TMS320C55X series 							   */

#include "lab4b.h"
#include "intrinsics.h"

extern int autocorr_in[L];
extern int autocorr_out[N];

void autocorr(void)
{
   int i,j,temp;

   _set_fract_bit();
   for(i=0;i<=M;++i)
   {
      long int sum=0;
      for(j=0;j<(L-i);++j)
      {
         temp = _i_mul_fract_fb1_ii(autocorr_in[j],autocorr_in[j+i]);
         sum += temp;
      }
      autocorr_out[i]=(int)(sum >> logL);
   }
   _reset_fract_bit();

   /* Copy values for negative indeces at end of buffer */
   for(i=1,j=N-1;i<=M;++i,--j)
   {  autocorr_out[j]=autocorr_out[i]; }
}