qpskwithcodec.txt

Qpsk signal Processing Code The DSP code should be efficient and accurate to properly demodulate th

Real Time Digital Signal Processor Code – Main.c file
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<common.h>
#include<mcbspdrv.h>
#include<board.h>
#include<codec.h>
#include<math.h>
#include<float.h>
#include"codec_ex.h"
#include"firf.h"
#definek10.0105
#definek20.0001
#defineSECONDS_TO_PLAY167
#defineSAMPS_PER_BUFF1024
#defineSAMPLE_RATE48000/*Hz,mediumquality.Highestrateforfirf.c*/
#defineMIC_INPUTFALSE/*Uselinelevelinput*/
#defineINPUT_GAIN0.0/*preampgainindB*/
#defineOUTPUT_ATTN0.0/*outputattenuationindB*/
#defineDATA_OUT_LENGTH3*SAMPS_PER_BUFF
#pragmaDATA_ALIGN(I,8);/*requiredtoavoidmemoryhitsinfirfa.asm*/
#pragmaDATA_ALIGN(Q,8);/*notethesearraysmustbeglobaltouseDATA_ALIGN*/
#pragmaDATA_ALIGN(mf_out,8);
#pragmaDATA_ALIGN(dmf_out,8);
/*----------------------------------------------------------------------------*/
/*EXTERNALS(Globalvariables)*/
/*----------------------------------------------------------------------------*/
floatI[(SAMPS_PER_BUFF+numH-1)],Q[(SAMPS_PER_BUFF+numH-1)],mf_out[SAMPS_PER_BUFF],
dmf_out[SAMPS_PER_BUFF],myout[SAMPS_PER_BUFF],myout2[SAMPS_PER_BUFF],zeros[SAMPS_PER_BUFF/8],
constellation[SAMPS_PER_BUFF/8];
intoutput_temp;
volatileintnumBuffsPlayed,out_done,in_done,ping_pong;
short*inBuffer0,*inBuffer1,*outBuffer0,*outBuffer1;
main(){
/*char*output=(char*)malloc(750*SECONDS_TO_PLAY*sizeof(char));*/
char*output=(char*)calloc(750*SECONDS_TO_PLAY,sizeof(char));
intcount9=0,count5=0;
Mcbsp_devdev=0;
/*arraysofpointerstoi/obuffers*/
short*inBuff[2],lut_indx,decision,prev_decision,*outBuff[2];
double*dummy;
unsignedintnumBytes,num_buffs_to_play;
intstatus,i,j,n,a,m,loop_ent=0;
floatsine[1024],cosine[1024];
floatagc=1,mag_squared=0,new_tot=0,ave_mag=1,filter_out=0,value1=0,value2=0,
trigger=1,prev_trigger=1,add_block=0,sample_and_hold_out=0,sample_out=0,

multiply_out=0,
DF_out=0,prev_DF_out=0,loop_add_out=0,angle=0,re_correction=1,im_correction=0,constant1=.1597,
constant2=.0142,I_prev=0,Q_prev=0,cr_filt=0,In=0,Qn=0,freq_detect=0,phase_detect=0,
error_sum=0,prev_cr_filt=0,total_cr_filt=0;
FILE*fpout;
a=0;
m=0;
/*UsethismallocmemorydeclarationtoputvarsinSDRAM0*/
/*float*xL,*xR,*yL,*yR;
xL=(float*)malloc((SAMPS_PER_BUFF+numH-1)*sizeof(float));
xR=(float*)malloc((SAMPS_PER_BUFF+numH-1)*sizeof(float));
yL=(float*)malloc(SAMPS_PER_BUFF*sizeof(float));*/
numBytes=SAMPS_PER_BUFF*4;/*two16bitshortspersamplegivepackedLandRchannels*/
num_buffs_to_play=(SAMPLE_RATE*SECONDS_TO_PLAY)/SAMPS_PER_BUFF;
numBuffsPlayed=0;/*Changeto1?*/
/***************************************************************************/
/*StartcodecContinuousDMAsimultaneouscaptureandplaybackoverMcBSP*/
/*withping-pongbuffers.Initialization,andstartI/Oinbackground*/
/*ThisalsoallocatesdatabuffersinBuffer0/1andoutBuffer0/1*/
/***************************************************************************/
status=CodecContDMAio(MIC_INPUT,SAMPLE_RATE,INPUT_GAIN,OUTPUT_ATTN,numBytes,dev);
if(status==ERROR){
printf("ErrorcallingCodecExContCapPb()\n");
return(ERROR);
}
/*SetarrayofpointerstopointtoI/ObufferssetupbyCodecContDMAio*/
inBuff[0]=inBuffer0;
inBuff[1]=inBuffer1;
outBuff[0]=outBuffer0;
outBuff[1]=outBuffer1;
for(lut_indx=0;lut_indx<1024;lut_indx++){
angle=(lut_indx-512)*.00613592;
sine[lut_indx]=sinf(angle);
cosine[lut_indx]=cosf(angle);
}
/***************************************************************************/
/*MainReal-Timecodesegment.*/
/***************************************************************************/
while(numBuffsPlayed<(num_buffs_to_play-1)){
/*YourReal-timecodegoeshere*/
/*Usein_doneasaflagtoindicateabufferofdataisreadytoprocess.
ping_pongisaflagtotellyouwhichbuffer(inBuffer0or1)was
justfilledwithreceivedata.inBuff[0]pointstoinBuffer0array,
etc.in_doneissetTRUEeachtimeoneoftheinputbuffersisfilled.
Sampleddatainthebuffersis16bitshort,packedalternatingleft

andrightchannels.*/
while(!in_done){}/*Waitfornextping_pongbuffertofill*/
in_done=FALSE;
for(i=0,j=0;i<SAMPS_PER_BUFF;i++){/*2bytes/sample,L&Rchannels*/
j=i+numH-1;
I[j]=(float)inBuff[ping_pong][i<<1];
Q[j]=(float)inBuff[ping_pong][(i<<1)+1];
}
/*Automaticgaincontrolloop*/
mag_squared=0;
for(i=numH-1;i<SAMPS_PER_BUFF+numH-1;i++)
{
I[i]=I[i]*agc;
Q[i]=Q[i]*agc;
mag_squared+=I[i]*I[i]+Q[i]*Q[i];
/*Frequencyandphasedetectionloopgoeshere*/
if(loop_ent==1){
In=I[i];
Qn=Q[i];
I[i]=In*re_correction-Qn*im_correction;
Q[i]=Qn*re_correction+In*im_correction;
/*frequencydetector*/
freq_detect=I[i]*Q_prev-Q[i]*I_prev;
I_prev=I[i];
Q_prev=Q[i];
/*phasedetector*/
if(I[i]>0)
phase_detect=Q[i];
else
phase_detect=-Q[i];
/*loopfilter*/
error_sum=phase_detect+freq_detect;
prev_cr_filt=cr_filt;
cr_filt=constant2*error_sum+prev_cr_filt;
total_cr_filt=cr_filt+constant1*error_sum;
/*DiscreteVCO*/
new_tot=new_tot+total_cr_filt;
lut_indx=(short)new_tot*10430.37835;
lut_indx=(lut_indx>>6)+512;
re_correction=cosine[lut_indx];
im_correction=-sine[lut_indx];
}
}
ave_mag=.000976*mag_squared;
if(ave_mag<.2)
loop_ent=1;
elseloop_ent=0;
filter_out=filter_out+value2;

value1=.5*logf(ave_mag);
value2=.05*(-1.2-value1);
agc=expf(filter_out);
/*ThisfunctioncallstheassemblycodeFIRfilter*/
fir(I,h,mf_out,numH,SAMPS_PER_BUFF);
fir(I,d,dmf_out,numD,SAMPS_PER_BUFF);
if(loop_ent==1){
n=0;
for(i=0;i<SAMPS_PER_BUFF;i++){
/*Offsetindex*/
/*Triggercalculation*/
prev_trigger=trigger;
trigger=(float)modf(add_block,dummy);
/*Triggeredsampleandholdandtriggeredsample*/
if(trigger<prev_trigger){
sample_and_hold_out=mf_out[i];
sample_out=dmf_out[i];
}
else
sample_out=0;
myout[i]=1-add_block;
myout2[i]=sample_and_hold_out;
/*Signblockandmultiply*/
if(sample_and_hold_out>0)
multiply_out=-sample_out;/*signsreversedfortestingpuposes*/
elseif(sample_and_hold_out<0)
multiply_out=sample_out;
else
multiply_out=0;
/*Loopfilter*/
DF_out=k2*multiply_out+prev_DF_out;
loop_add_out=k1*multiply_out+DF_out;
prev_DF_out=DF_out;
/*Addblock*/
add_block=0.125-loop_add_out+trigger;
/*Downsampleoutputofmatchedfilter*/
if(trigger<prev_trigger){/*i%8==0){*/
/*Signblock*/
if(sample_and_hold_out>0)
decision=1;
elseif(sample_and_hold_out<0)
decision=-1;
else
decision=0;
/*Differentialdecoder*/
output_temp=-prev_decision*decision;
if(output_temp==-1)

{output_temp=0;}
output[m]=(output[m]<<1)+(char)output_temp;
count5++;
count9++;
if(count5==8){
count5=0;
m++;
}
if(count9==511){
output[m]=(output[m]<<1);
count5=0;
count9=0;
m++;
}
/*if(a==510){
a=-1;
output_temp[511]=0;
for(count9=0;count9<64;count9++){
for(count5=0;count5<8;count5++){
if(output_temp[((count9*8)+count5)]==-1)
{output_temp[((count9*8)+count5)]=0;}
alpha[count9]=(alpha[count9]<<1)+output_temp[(count9*8+count5)];
}
}
for(count9=0;count9<64;count9++){
output[m]=alpha[count9];
alpha[count9]=0;
m++;
}
}*/
prev_decision=decision;
constellation[n]=sample_and_hold_out;
zeros[n]=0;
/*Outputdata*/
/*outBuff[ping_pong][i<<1]=(short)decode_out;
outBuff[ping_pong][(i<<1)+1]=0;*/
n++;
a++;
}
}
}
/*Fillthefilterbufferoverlappipeline*/
for(i=0;i<numH-1;i++){
j=i+SAMPS_PER_BUFF;
I[i]=I[j];
Q[i]=Q[j];
}

}
/***************************************************************************/
/*ResetandreleaseDMAcontroller,Codec,anddatabuffers(ifallocated*/
/*usingMALLOC).Thiscleansthingsupbeforereturningtoanother*/
/*program.*/
/***************************************************************************/
printf("ThatsAllFolks\n");
if((fpout=fopen("c:\\Data\\data_out.bin","wb"))==NULL){
printf("\nCouldnotopen%s.Abort.\n","c:\\Data\\data_out.bin");
exit(EXIT_FAILURE);
}
if((fwrite(output,sizeof(char),(m),fpout))==0){
printf("Diskwriteerror");
exit(EXIT_FAILURE);
}
fclose(fpout);
free(output);
printf("ThatsREALLYAllFolks\n");
/*printf("variable%5fvariable2%5d",variable,variable2)*/
releaseDMAandDAC(dev);
mcbsp_close(dev);
return(OK);
}
BER Test Code
This code was run in the Visual C++ Studio on the host PC, after the acquired and decoded binary sequence was written to a file on the PC.
#include<stdio.h>
#include<stdlib.h>
#include"input_array.h"
voidunpacker(char*packed,int*unpacked);
voidmain(){
intm,n,mag,offset,errors,total_bits,all_bits,stream[1022];
charpacked_input[64];
floatBER;
FILE*fpin;
offset=0;
errors=0;
total_bits=0;
all_bits=0;
if((fpin=fopen("c:\\Data\\data_out.bin","rb"))==NULL){
printf("\nCouldnotopen%s.Abort.\n","c:\\Data\\data_out.bin");
exit(EXIT_FAILURE);
}

if(fread(packed_input,sizeof(char),64,fpin)!=64){
printf("Errorininitialread.");
exit(EXIT_FAILURE);
}
unpacker(packed_input,stream);
//whilethefreadyieldsvalidinput
while(fread(packed_input,sizeof(char),64,fpin)==64){
unpacker(packed_input,&stream[511]);
all_bits=all_bits+511;
for(n=0,mag=0;n<511;n++){
m=n+offset;
mag+=expected[n]*stream[m];
}
//ifthemagnitudedropsbelow410,reacquire
if(mag<409){
offset=-1;
while(mag<409&&offset<511){
offset++;
for(n=0,mag=0;n<511;n++){
m=n+offset;
mag+=expected[n]*stream[m];
}
}
}
if(mag>408){
errors+=((511-mag)/2);
total_bits+=511;
BER=((float)errors)/((float)total_bits);
//if(total_bits%10220==0)
printf("BER:%1.9ferrors:%3dtotal_bits:%7dallbits%7d\n",
BER,errors,total_bits,all_bits);
}
for(n=0;n<511;n++)
stream[n]=stream[n+511];
}
fclose(fpin);
}
voidunpacker(char*packed,int*unpacked){
charmask,temp;
inti,n_packed,n_unpacked;
mask=0x01;
n_packed=0;
n_unpacked=0;
while(n_packed<64){
if(n_packed<63){
for(i=7;i>-1;i--){
temp=packed[n_packed]>>i;
unpacked[n_unpacked]=(int)(mask&temp);
n_unpacked++;
}
}
else{
for(i=7;i>0;i--){

temp=packed[n_packed]>>i;
unpacked[n_unpacked]=(int)(mask&temp);
n_unpacked++;
}
}
n_packed++;
}
for(n_unpacked=0;n_unpacked<511;n_unpacked++){
if(unpacked[n_unpacked]==0){
unpacked[n_unpacked]=-1;
}
}
}