Program 5

Program-5

Aim:- To generate sinusoidal signal using DSK-6713 processor.

Coding:-/* DSP program generate the sine wave using lookup table *//* and produces an output stream. Output data are sent to host files */ /* using RTDX channels. Interface CCstudio with VB and display *//* the wave on VB graph screen *//***************************************************************************/

#include <std.h>

#include <log.h>#include <rtdx.h>

#include "rtdxsinecfg.h"

#include "target.h"

#define BUFSIZE 64#define BUFFERLENGTH 64#define MINVOLUME 1

typedef Int sample; /* representation of a data sample from A2D */

/* Global declarations */sample inp_buffer[BUFSIZE];int out_buffer[BUFFERLENGTH];

Int volume=0;

/* RTDX channels */RTDX_CreateInputChannel(control_channel);RTDX_CreateInputChannel(A2D_channel);RTDX_CreateOutputChannel(D2A1_channel);

Jai Kumar Soni

/* * ======== main ======== */Void main(){ sample *input = inp_buffer; Uns size = BUFSIZE; int sin_table[8] = {0,707,1000,707,0,-707,-1000,-707}; int i=0,loop=0; TARGET_INITIALIZE(); /* Enable RTDX interrupt */ // LOG_printf(&trace,"\n Sine Wave Example Started");

/* enable volume control input channel */

RTDX_enableInput(&control_channel);

while (TRUE){ /* Read a new volume when the hosts send it */ if (!RTDX_channelBusy(&control_channel)) { RTDX_readNB(&control_channel, &volume, sizeof(volume)); }

while (!RTDX_isInputEnabled(&A2D_channel)){#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for input*/#endif }

/* * A2D: get digitized input (get signal from the host through RTDX). * If A2D_channel is enabled, read data from the host. */ RTDX_read(&A2D_channel, input, size*sizeof(sample));

/* * D2A: produce analog output (send signal to the host through RTDX). * If D2A_channel is enabled, write data to the host. */

out_buffer[i]= sin_table[loop];

Jai Kumar Soni

i++;if (i== BUFFERLENGTH)i=0;if (++loop >7) loop = 0;

RTDX_write(&D2A1_channel,out_buffer, size*sizeof(sample));

while(RTDX_writing) {#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for output */#endif }

}}

Output :-

Jai Kumar Soni

Program-6

Aim:- To generate square wave signal using DSK-6713 processor.

Coding:-/* DSP program generate the Square wave using lookup table *//* and produces an output stream. Output data are sent to host files */ /* using RTDX channels. Interface CCstudio with VB and display *//* the wave on VB graph screen through RTDX channel *//***************************************************************************/

#include <std.h>

#include "rtdxsqurecfg.h"#include "dsk6713_aic23.h"#include "dsk6713.h"#include <log.h>#include <rtdx.h>#include "target.h"

#define BUFSIZE 64#define BUFFERLENGTH 64#define table_size 8 //size of table=48

typedef Int sample; /* representation of a data sample from A2D */

/* Global declarations */sample inp_buffer[BUFSIZE];sample out_buffer[BUFFERLENGTH];

Int volume=0;

/* RTDX channels */RTDX_CreateInputChannel(control_channel);RTDX_CreateInputChannel(A2D_channel);RTDX_CreateOutputChannel(D2A1_channel);

Jai Kumar Soni

int data_table[table_size]; //data table arraysample *input = inp_buffer;Uns size = BUFSIZE; int i=0,j=0;

/* * ======== main ======== */Void main(){ TARGET_INITIALIZE(); /* Enable RTDX interrupt */ // LOG_printf(&trace,"\n Square Wave Example Started"); /* enable volume control input channel */ RTDX_enableInput(&control_channel);

while (TRUE) { /* Read a new volume when the hosts send it */ if (!RTDX_channelBusy(&control_channel)) { RTDX_readNB(&control_channel, &volume, sizeof(volume)); }

while (!RTDX_isInputEnabled(&A2D_channel)){#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for input*/#endif }

/* * A2D: get digitized input (get signal from the host through RTDX). * If A2D_channel is enabled, read data from the host. */ RTDX_read(&A2D_channel, input, size*sizeof(sample));

/* * D2A: produce analog output (send signal to the host through RTDX). * If D2A_channel is enabled, write data to the host. */

for(i=0; i<=table_size/2; i++) //set 1st half of buffer

Jai Kumar Soni

{data_table[i] = 0x7FFF; //with max value (2^15)-1}for(i=table_size/2;i<table_size;i++) //set 2nd half of buffer{data_table[i] = -0x8000; //with -(2^15)}i = 0;

for(i=0; i<table_size/2; i++){out_buffer[j] = data_table[i]; //output to bufferj++;if(j==BUFFERLENGTH) j=0;}for(i=table_size/2;i<table_size;i++){out_buffer[j] = data_table[i]; //output to bufferj++;if(j==BUFFERLENGTH) j=0;}i=0;

RTDX_write(&D2A1_channel,out_buffer, size*sizeof(sample));printf("hello");

while(RTDX_writing){#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for output */#endif }

}}

Jai Kumar Soni

Output :-

Jai Kumar Soni

Program-7

Aim:- To generate triangular wave signal using DSK-6713 processor.

Coding:-/* DSP program generate the Triangular wave using lookup table *//* and produces an output stream. Output data are sent to host files */ /* using RTDX channels. Interface CCstudio with VB and display *//* the wave on VB graph screen through RTDX channel *//***************************************************************************/

#include <std.h> #include"rtdxtrangcfg.h"#include "dsk6713_aic23.h"#include "dsk6713.h"#include <log.h>#include <rtdx.h>#include "target.h"

#define BUFSIZE 64#define BUFFERLENGTH 64

/* Length of sine wave table */#define TABLE_SIZE 24

typedef Int sample; /* representation of a data sample from A2D */

/* Global declarations */sample inp_buffer[BUFSIZE];

Int volume=0;// = MINVOLUME; /* the scaling factor for volume control */

Jai Kumar Soni

/* RTDX channels */RTDX_CreateInputChannel(control_channel);RTDX_CreateInputChannel(A2D_channel);RTDX_CreateOutputChannel(D2A1_channel);

int out_buffer[256]; int loop=0;int i=0;sample *input = inp_buffer;Uns size = BUFSIZE; int trang_table[TABLE_SIZE]= { 0, 2000, 4000, 6000, 8000, 10000, 12000, 10000, 8000, 6000, 4000, 2000, 0, -2000, -4000, -6000, -8000, -10000,-12000,-10000, -8000, -6000 ,-4000, -2000 };//table valuesint out_buffer[256]; //output buffer

void main(){

TARGET_INITIALIZE(); /* Enable RTDX interrupt */ //LOG_printf(&trace,"\n Trangularwave example started"); /* enable volume control input channel */ RTDX_enableInput(&control_channel);

while (TRUE) { /* Read a new volume when the hosts send it */ if (!RTDX_channelBusy(&control_channel)) { RTDX_readNB(&control_channel, &volume, sizeof(volume)); }

while (!RTDX_isInputEnabled(&A2D_channel)){#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for input*/#endif }

/* * A2D: get digitized input (get signal from the host through RTDX). * If A2D_channel is enabled, read data from the host. */ RTDX_read(&A2D_channel, input, size*sizeof(sample));

Jai Kumar Soni

/* * D2A: produce analog output (send signal to the host through RTDX). * If D2A_channel is enabled, write data to the host. */

out_buffer[i] = trang_table[loop]; //output to bufferi++; if(i==BUFFERLENGTH) i=0; //if @ bottom reinit countif (++loop > 23) loop = 0;

RTDX_write(&D2A1_channel,out_buffer, size*sizeof(sample));printf("hello");

while(RTDX_writing) {#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for output */#endif }}}

Output :-

Jai Kumar Soni

Program-8

Aim:- To perform linear convolution using DSK-6713 processor.

Coding:-#include<stdio.h>#include "linearcfg.h"#include "dsk6713.h"#include "dsk6713_aic23.h"#include "rtdx.h" #include "target.h"

#define BUFSIZE 7

/* Codec configuration settings */DSK6713_AIC23_Config config = { 0x0017, // 0 DSK6713_AIC23_LEFTINVOL Left line input channel volume 0x0017, // 1 DSK6713_AIC23_RIGHTINVOL Right line input channel volume 0x00d8, // 2 DSK6713_AIC23_LEFTHPVOL Left channel headphone volume 0x00d8, // 3 DSK6713_AIC23_RIGHTHPVOL Right channel headphone volume 0x0011, // 4 DSK6713_AIC23_ANAPATH Analog audio path control 0x0000, // 5 DSK6713_AIC23_DIGPATH Digital audio path control 0x0000, // 6 DSK6713_AIC23_POWERDOWN Power down control 0x0043, // 7 DSK6713_AIC23_DIGIF Digital audio interface format 0x0001, // 8 DSK6713_AIC23_SAMPLERATE Sample rate control 0x0001 // 9 DSK6713_AIC23_DIGACT Digital interface activation}; Uint32 fs = DSK6713_AIC23_FREQ_32KHZ; //set sampling rate

Int volume =1; /* the scaling factor for volume control */

/* RTDX channels */

RTDX_CreateInputChannel(control_channel); RTDX_CreateInputChannel(A2D_channel); RTDX_CreateOutputChannel(D2A1_channel); RTDX_CreateOutputChannel(D2A2_channel);

Jai Kumar Soni

typedef Int sample; /* representation of a data sample from A2D */

int m=4; /*Lenght of i/p samples sequence*/int n=4; /*Lenght of impulse response Co-efficients */

int x[7]={1,2,3,4,0,0,0}; /*Input Signal Samples*/int h[7]={1,2,3,4,0,0,0};

sample inp_buffer[7];

int out_buffer[10];

sample *input = inp_buffer; int *output = out_buffer; Uns size = BUFSIZE; int i=0,j;

void main(){

DSK6713_AIC23_CodecHandle hCodec; //Int16 msec;

/* Initialize the board support library, must be called first */ DSK6713_init();

/* Start the codec */ hCodec = DSK6713_AIC23_openCodec(0, &config);

DSK6713_AIC23_setFreq( hCodec, fs);

TARGET_INITIALIZE(); /* Enable RTDX interrupt */ // LOG_printf(&trace,"hostio example started"); /* enable volume control input channel */ RTDX_enableInput(&control_channel);

while (TRUE) { /* Read a new volume when the hosts send it */ if (!RTDX_channelBusy(&control_channel)) { RTDX_readNB(&control_channel, &volume, sizeof(volume)); }

while (!RTDX_isInputEnabled(&A2D_channel)){#if RTDX_POLLING_IMPLEMENTATION

Jai Kumar Soni

RTDX_Poll(); /* poll comm channel for input*/#endif }

/* * A2D: get digitized input (get signal from the host through RTDX). * If A2D_channel is enabled, read data from the host. */ RTDX_read(&A2D_channel,input, size*sizeof(sample));

/* * Vector Scale: Scale the input signal by the volume factor to * produce the output signal*/

while(size--) {

for(i=0;i<m+n-1;i++){out_buffer[i]=0;for(j=0;j<=i;j++)

out_buffer[i]+=x[j]*h[i-j];}

// for(i=0;i<m+n-1;i++)

// printf("%d\n",out_buffer[i]);

}

size = BUFSIZE; input = inp_buffer; output = out_buffer;

/* * D2A: produce analog output (send signal to the host through RTDX). * If D2A_channel is enabled, write data to the host. */

RTDX_write(&D2A1_channel,out_buffer, size*sizeof(sample)); while(RTDX_writing){

#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for output */#endif

Jai Kumar Soni

}}}

Output :-

Jai Kumar Soni

Program-9

Aim:- To design an FIR filter using DSK-6713 processor.

Coding:-*Purpose ; This program explains FIR Filter. input is internally generated noise.The band pass filter we designed is of the order 41.*************************************************************************************************/

#include"fircfg.h"#include"dsk6713.h"#include "dsk6713_aic23.h"

#include "bp41.h"

#include "noise_gen.h" #include "rtdx.h"#include "target.h" #include <math.h>#define BUFSIZE 41#define MINVOLUME 1 //delay samples short fb; //feedback variableshift_reg sreg;short prn(void) ;

/* Codec configuration settings */DSK6713_AIC23_Config config = { \ 0x0017, /* 0 DSK6713_AIC23_LEFTINVOL Left line input channel volume */ \ 0x0017, /* 1 DSK6713_AIC23_RIGHTINVOL Right line input channel volume */\ 0x01f9, /* 2 DSK6713_AIC23_LEFTHPVOL Left channel headphone volume */ \ 0x01f9, /* 3 DSK6713_AIC23_RIGHTHPVOL Right channel headphone volume */ \ 0x0012, /* 4 DSK6713_AIC23_ANAPATH Analog audio path control */ \ 0x0001, /* 5 DSK6713_AIC23_DIGPATH Digital audio path control */ \ 0x0002, /* 6 DSK6713_AIC23_POWERDOWN Power down control */ \ 0x0043, /* 7 DSK6713_AIC23_DIGIF Digital audio interface format */ \

Jai Kumar Soni

0x0023, /* 8 DSK6713_AIC23_SAMPLERATE Sample rate control */ \ 0x0001 /* 9 DSK6713_AIC23_DIGACT Digital interface activation */ };

typedef Int sample; /* representation of a data sample from A2D */

/* Global declarations */sample inp_buffer[BUFSIZE];int out_buffer[BUFSIZE];short buffercount = 0; //init buffer countconst short bufferlength =1024; Int volume =1; /* the scaling factor for volume control */ /* RTDX channels */

RTDX_CreateInputChannel(control_channel); RTDX_CreateInputChannel(A2D_channel); RTDX_CreateOutputChannel(D2A_channel); RTDX_CreateOutputChannel(D2A1_channel);RTDX_CreateOutputChannel(D2A2_channel);

int *input = inp_buffer; int *output =out_buffer; Uns size = BUFSIZE; int i; int yn=0; //initialize filter's output short yn_buffer[1024];

main() {

int dly[N]; DSK6713_AIC23_CodecHandle hCodec;

/* Initialize the board support library, must be called first */ DSK6713_init();

TARGET_INITIALIZE(); /* Enable RTDX interrupt */ /* Start the codec */ hCodec = DSK6713_AIC23_openCodec(0, &config); /*set codec sampling frequency*/ DSK6713_AIC23_setFreq(hCodec,1);

Jai Kumar Soni

/* enable volume control input channel */ RTDX_enableInput(&control_channel);

while (TRUE) { /* Read a new volume when the hosts send it */ if (!RTDX_channelBusy(&control_channel)) { RTDX_readNB(&control_channel, &volume, sizeof(volume)); }

while (!RTDX_isInputEnabled(&A2D_channel)){#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for input*/#endif }

RTDX_read(&A2D_channel,input, size*sizeof(sample));

dly[0] = prn(); //input noise sequence yn = 0; //initialize filter's outputfor (i = 0; i< N; i++) yn+=(h[i]*dly[i])>>15; //y(n)+=h(i)*x(n-i)

for (i = N-1; i > 0; i--) //start @ bottom of buffer dly[i] = dly[i-1]; //data move to update delays

while (!DSK6713_AIC23_write(hCodec, ((short)yn))); //output filter

yn_buffer[buffercount] = yn; //filter's output into bufferbuffercount++; //increment buffer countif(buffercount==bufferlength) //if buffer count = size buffercount = 0; //reinitialize buffer count

sreg.regval = 0xFFFF; //shift register to nominal values

fb = 1; //initial feedback value

/* * D2A: produce analog output (send signal to the host through RTDX). * If D2A_channel is enabled, write data to the host. */

RTDX_write(&D2A1_channel,dly, size*sizeof(sample)); while(RTDX_writing){

#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for output */#endif

Jai Kumar Soni

}

RTDX_write(&D2A2_channel,yn_buffer, size*sizeof(sample));

while(RTDX_writing){#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for output */#endif }}}

short prn(void) //pseudorandom noise generation { short prnseq; //for pseudorandom sequence if(sreg.bt.b0) //sequence {1,-1}

prnseq = -16000; //scaled negative noise level else

prnseq = 16000; //scaled positive noise level fb =(sreg.bt.b0)^(sreg.bt.b1); //XOR bits 0,1 fb ^=(sreg.bt.b11)^(sreg.bt.b13); //with bits 11,13 ->fb sreg.regval<<=1; //shift register 1 bit to left sreg.bt.b0 = fb; //close feedback path return prnseq;

} //return sequence

Jai Kumar Soni

Output :-

Jai Kumar Soni

Program-10

Aim:- To design an IIR filter using DSK-6713 processor.

Coding:-

#include "iirfiltercfg.h"#include "dsk6713.h"#include "dsk6713_aic23.h"#include <rtdx.h>#include "target.h"#define BUFSIZE 31 #define MINVOLUME 1typedef Int sample;

signed int filter_Coeff[] = { // 0.388513,-0.777027,0.388513,1.000000,-1.118450,0.645091 // 12730,-12730,12730,2767,-18324,21137 /*HP 2500 */ //312,312,312,32767,-27943,24367 /*LP 800 */ //1455,1455,1455,32767,-23140,21735 /*LP 1000 */ 9268,-9268,9268,32767,-7395,18367 /*HP 4000*/ // 7215,-7215,7215,32767,5039,6171, /*HP 5000*/} ;

Uint32 inp_buffer[BUFSIZE];Uint32 out_buffer[BUFSIZE];Int volume = MINVOLUME;

RTDX_CreateInputChannel(control_channel);RTDX_CreateInputChannel(A2D_channel); RTDX_CreateOutputChannel(D2A1_channel); RTDX_CreateOutputChannel(D2A2_channel);/* Codec configuration settings */DSK6713_AIC23_Config config = { \

Jai Kumar Soni

0x001b, /* 0 DSK6713_AIC23_LEFTINVOL Left line input channel volume */ \ 0x001b, /* 1 DSK6713_AIC23_RIGHTINVOL Right line input channel volume */\ 0x00d8, /* 2 DSK6713_AIC23_LEFTHPVOL Left channel headphone volume */ \ 0x00d8, /* 3 DSK6713_AIC23_RIGHTHPVOL Right channel headphone volume */ \ 0x0011, /* 4 DSK6713_AIC23_ANAPATH Analog audio path control */ \ 0x0000, /* 5 DSK6713_AIC23_DIGPATH Digital audio path control */ \ 0x0000, /* 6 DSK6713_AIC23_POWERDOWN Power down control */ \ 0x0043, /* 7 DSK6713_AIC23_DIGIF Digital audio interface format */ \ 0x0081, /* 8 DSK6713_AIC23_SAMPLERATE Sample rate control */ \ 0x0001 /* 9 DSK6713_AIC23_DIGACT Digital interface activation */ \};main(){DSK6713_AIC23_CodecHandle hCodec;Uint32 l_input, r_input, l_output;Uint32 *input = inp_buffer;Uint32 *output = out_buffer;Uns size = BUFSIZE;

int j,m; /* Initialize the board support library, must be called first */ DSK6713_init();

TARGET_INITIALIZE(); RTDX_enableInput(&control_channel); RTDX_enableInput(&A2D_channel); RTDX_enableOutput(&D2A1_channel); RTDX_enableOutput(&D2A2_channel); /* Start the codec */ hCodec = DSK6713_AIC23_openCodec(0, &config); DSK6713_AIC23_setFreq(hCodec, 3);

while(1){

for(j=0;j<BUFSIZE;j++) { /* Read a sample to the left channel */

while (!DSK6713_AIC23_read(hCodec, &l_input));

Jai Kumar Soni

/* Read a sample to the right channel */ while (!DSK6713_AIC23_read(hCodec, &r_input));

l_output=IIR_FILTER(&filter_Coeff ,l_input); //r_output=l_output;

out_buffer[j]=l_output;

} RTDX_read(&A2D_channel, input, size*sizeof(sample)); if (!RTDX_channelBusy(&control_channel)) { RTDX_readNB(&control_channel, &volume, sizeof(volume)); }

while (!RTDX_isInputEnabled(&A2D_channel)){#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for input*/

#endif } j=0; while(size--){ *output++ = out_buffer[j++]; } size = BUFSIZE; input = inp_buffer; output = out_buffer; /* D2A: produce analog output (send signal to the host through RTDX). * If D2A_channel is enabled, write data to the host. */ /* for(m=0;m<50000;m++)

{ RTDX_write(&D2A_channel, l_input, size*sizeof(sample));}*/

for(m=0;m<50000;m++){

RTDX_write(&D2A2_channel, filter_Coeff, size*sizeof(sample));}for(m=0;m<50000;m++)

Jai Kumar Soni

{RTDX_write(&D2A1_channel,out_buffer , size*sizeof(sample));

} while(RTDX_writing){#if RTDX_POLLING_IMPLEMENTATION RTDX_Poll(); /* poll comm channel for output */#endif

} /* Close the codec */ // DSK6713_AIC23_closeCodec(hCodec);}}

signed int IIR_FILTER(signed int * h, signed int x1){

static signed int x[6] = { 0, 0, 0, 0, 0, 0 }; /* x(n), x(n-1), x(n-2). Must be static */ static signed int y[6] = { 0, 0, 0, 0, 0, 0 }; /* y(n), y(n-1), y(n-2). Must be static */ int temp=0;

temp = (short int)x1; /* Copy input to temp */

x[0] = (signed int) temp; /* Copy input to x[stages][0] */ temp = ( (int)h[0] * x[0]) ; /* B0 * x(n) */ temp += ( (int)h[1] * x[1]); /* B1/2 * x(n-1) */

temp += ( (int)h[1] * x[1]); /* B1/2 * x(n-1) */ temp += ( (int)h[2] * x[2]); /* B2 * x(n-2) */ temp -= ( (int)h[4] * y[1]); /* A1/2 * y(n-1) */ temp -= ( (int)h[4] * y[1]); /* A1/2 * y(n-1) */ temp -= ( (int)h[5] * y[2]); /* A2 * y(n-2) */ /* Divide temp by coefficients[A0] */ temp >>= 15;

if ( temp > 32767 ) { temp = 32767; } else if ( temp < -32767) { temp = -32767; } y[0] = temp ;

Jai Kumar Soni

/* Shuffle values along one place for next time */ y[2] = y[1]; /* y(n-2) = y(n-1) */ y[1] = y[0]; /* y(n-1) = y(n) */ x[2] = x[1]; /* x(n-2) = x(n-1) */ x[1] = x[0]; /* x(n-1) = x(n) */

/* temp is used as input next time through */ return (temp<<2); }

Output :-

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni

Jai Kumar Soni