hardviterbiqpskinawgn.c

Hard Viterbi QPSK in AWGN, Rayleight soft Viterbi QAM in AWGN, Rayleight viterbi QAM in AWGN, Rayl

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include "random.h"
//make struct complex
typedef struct complex1
{
	double real;
	double imag;
} complex;
// define the number of interation 
#define ITERATION pow(10, 4)
#define THENUMBEROFDATA 1000

void convolution(int *data, int *codeddata);
double modulation(int data);
double demodulation(double r_data);
int bercheck(int data, double d_data);
double comparison(double com1, double com2);
void viterbi_decode(int *d_data, int *decode_data);
void quantization(double r_data, int *d_data);
double dis(int data, int data1, int data2, int data3, int data4, int data5, int value1, int value2);

void main()
{
	FILE *fp1;
	double Noisepower;
	complex Noise;
	int data[THENUMBEROFDATA];
	int codeddata[2*(THENUMBEROFDATA+2)];
	int l;
	//int s[4][THENUMBEROFDATA+3];
	//int ll;
	//int dd_data[4];
	complex m_data;
	complex r_data;
	complex H;
	complex er_data;
	int d_data[3];
	int d_data1[3];
	int dd_data[6*(THENUMBEROFDATA+2)];
	int decode_data[THENUMBEROFDATA+2];
	int error;
	//int error1;
	double avgerr;
	int EbofN0;
//	int viter;
	// open the file 
	fp1=fopen("result_qpsk_ViterbiSoft.txt","w");
	srand(time(0));

	
	for(EbofN0=11; EbofN0<=15; EbofN0+=1)
	{
		double sumerr=0;
		int run;		
	    int i;
		//int k;
		for(run=0;run<ITERATION;run++)
		{
			// create the data
			generate_random(&data[0], THENUMBEROFDATA);
			// create convolution code
			/*data[0] = 1;
			data[1] = 0;
			data[2] = 1;
			data[3] = 1;
             */
			convolution(data, codeddata);					

            for (i=0; i<=(THENUMBEROFDATA+1);i++)
			{
			    //printf("%d%d ",codeddata[2*i],codeddata[2*i+1]);
				//modulate the real and imagine of the data 
				m_data.real = modulation(codeddata[2*i]);
				m_data.imag = modulation(codeddata[2*i+1]);
			    // make the noisepower
		        Noisepower=1/(1*pow(10,(double)EbofN0/10));
			    // create the noise 
		        Noise.real = sqrt(Noisepower/2)*GaussRand();
			    Noise.imag = sqrt(Noisepower/2)*GaussRand();

				//H.real = sqrt(1.0/2.0)*GaussRand();
				//H.imag = sqrt(1.0/2.0)*GaussRand();
			    // receive the signal (modulated data + noise)

			    r_data.real = sqrt(1.0/2.0)*m_data.real + Noise.real;
			    r_data.imag = sqrt(1.0/2.0)*m_data.imag + Noise.imag;

			    //er_data.real = (r_data.real*H.real+r_data.imag*H.imag)/(pow(H.real,2)+pow(H.imag,2));
				//er_data.imag = (r_data.imag*H.real-r_data.real*H.imag)/(pow(H.real,2)+pow(H.imag,2));

			    // demodulate the signal

				quantization(r_data.real,d_data);
				quantization(r_data.imag,d_data1);

				dd_data[6*i]=d_data[0];
				dd_data[6*i+1]=d_data[1];
				dd_data[6*i+2]=d_data[2];
				dd_data[6*i+3]=d_data1[0];
				dd_data[6*i+4]=d_data1[1];
				dd_data[6*i+5]=d_data1[2];
			    //d_data[2*i] = (int)demodulation(r_data.real);
			    //d_data[2*i+1] = (int)demodulation(r_data.imag);
				//printf("%f\n",r_data.real);
                //printf("d_data = %d,%d\n",d_data[2*i],d_data[2*i+1]);
			}
		    //printf("\n");
            
            viterbi_decode(dd_data,decode_data);
			
			//printf("%d,",d_data[2*i],d_data[2*i+1]);
			//data[THENUMBEROFDATA]=0;
			//data[(THENUMBEROFDATA+1)]=0;
			for (l=0;l<=(THENUMBEROFDATA-1);l++)
			{				
				//printf("%d=",decode_data[l]);
				//printf("%d\n",data[l]);
				error= bercheck(data[l], decode_data[l]);
				sumerr = sumerr + error;
			}			
		}		
		// calculate the BER
		avgerr = (double)sumerr /ITERATION /THENUMBEROFDATA;
		fprintf(fp1,"%.7f\n",avgerr);
		printf("%.7f\n", avgerr);
	}
	fclose(fp1);
}

void quantization(double r_data, int *d_data)
{
	if (r_data<=-sqrt(1.0/2.0)*3/4)
	{
		d_data[0]=0;
		d_data[1]=0;
		d_data[2]=0;
	}else if (r_data<=-sqrt(1.0/2.0)*2/4)
	{
		d_data[0]=0;
		d_data[1]=0;
		d_data[2]=1;
	}else if (r_data<=-sqrt(1.0/2.0)*1/4)
	{
		d_data[0]=0;
		d_data[1]=1;
		d_data[2]=0;
	}else if (r_data <= 0 )
	{
		d_data[0]=0;
		d_data[1]=1;
		d_data[2]=1;
	}else if (r_data<=sqrt(1.0/2.0)*1/4)
	{
		d_data[0]=1;
		d_data[1]=0;
		d_data[2]=0;
	}else if (r_data<=sqrt(1.0/2.0)*2/4)
	{
		d_data[0]=1;
		d_data[1]=0;
		d_data[2]=1;
	}else if (r_data<=sqrt(1.0/2.0)*3/4)
	{
		d_data[0]=1;
		d_data[1]=1;
		d_data[2]=0;
	}else 
	{
		d_data[0]=1;
		d_data[1]=1;
		d_data[2]=1;
	}
}

void convolution(int *data, int *codeddata)
{
	int a = data[0];
	int b = 0;
	int c = 0;
	int N =0;
	//int codeddata[12];
	for(N=0;N<=(THENUMBEROFDATA+1);N++)
	{
		codeddata[2*N] = a^b^c;
		codeddata[2*N+1] = a^c;
		a = data[N+1];
		b = data[N];
		if(N == 0)
		{
			c = 0;
		}else
		{
			c = data[N-1];
		}
		if(N>=(THENUMBEROFDATA-1))
		{
			a=0;
		}
		if(N>=THENUMBEROFDATA)
		{
			b=0;
		}
	}
}
// modulation function
double modulation(int data)
{
	int m_data;
	if (data==1)
	{
		m_data=1;
	}
	else
	{
		m_data=-1;
	}
	return (m_data);
}
// demodulation function
double demodulation(double r_data)
{
	int d_data;
	if (r_data>=0)
	{
		d_data=1;
	}
	else
	{
		d_data=0;
	}
	return (d_data);
}
// error check function
int bercheck(int data, double d_data)
{
	int error=0;
	if ((double)data==d_data)
	{
		error=0;
	}
	else
	{
		error=1;
	}
	return (error);
}

void viterbi_decode(int *d_data, int *decode_data)
{
	double s[4][(THENUMBEROFDATA+3)];
	int k1;
	int k2;
	int c[(THENUMBEROFDATA+2)];
	int l1;
//	int l2;
	int i;
	int l;
	for (i = 0;i<=3;i++)
	{
		for(l=0;l<=THENUMBEROFDATA+2;l++)
		{
			s[i][l]=10000000000000;
		}
	}
    s[0][0]=0;
	s[0][1]=dis(d_data[0],d_data[1],d_data[2],d_data[3],d_data[4],d_data[5],0,0);
	s[1][1]=dis(d_data[0],d_data[1],d_data[2],d_data[3],d_data[4],d_data[5],1,1);
	s[0][2]=s[0][1]+dis(d_data[6],d_data[7],d_data[8],d_data[9],d_data[10],d_data[11],0,0);
	s[1][2]=s[0][1]+dis(d_data[6],d_data[7],d_data[8],d_data[9],d_data[10],d_data[11],1,1);
	s[2][2]=s[1][1]+dis(d_data[6],d_data[7],d_data[8],d_data[9],d_data[10],d_data[11],1,0);
	s[3][2]=s[1][1]+dis(d_data[6],d_data[7],d_data[8],d_data[9],d_data[10],d_data[11],0,1);
	
	for(k2=3;k2<=(THENUMBEROFDATA+2);k2++)
	{
		for(k1=0;k1<=3;k1++)
		{
			if(k1==0)
			{
				s[k1][k2]=comparison(s[k1][k2-1]+dis(d_data[6*(k2-1)],d_data[6*(k2-1)+1],d_data[6*(k2-1)+2],d_data[6*(k2-1)+3],d_data[6*(k2-1)+4],d_data[6*(k2-1)+5],0,0), s[k1+2][k2-1]+dis(d_data[6*(k2-1)],d_data[6*(k2-1)+1],d_data[6*(k2-1)+2],d_data[6*(k2-1)+3],d_data[6*(k2-1)+4],d_data[6*(k2-1)+5],7,7));
			}
			else if(k1==1)
			{
				s[k1][k2]=comparison(s[k1-1][k2-1]+dis(d_data[6*(k2-1)],d_data[6*(k2-1)+1],d_data[6*(k2-1)+2],d_data[6*(k2-1)+3],d_data[6*(k2-1)+4],d_data[6*(k2-1)+5],7,7), s[k1+1][k2-1]+dis(d_data[6*(k2-1)],d_data[6*(k2-1)+1],d_data[6*(k2-1)+2],d_data[6*(k2-1)+3],d_data[6*(k2-1)+4],d_data[6*(k2-1)+5],0,0));
			}
			else if(k1==2)
			{
				s[k1][k2]=comparison(s[k1-1][k2-1]+dis(d_data[6*(k2-1)],d_data[6*(k2-1)+1],d_data[6*(k2-1)+2],d_data[6*(k2-1)+3],d_data[6*(k2-1)+4],d_data[6*(k2-1)+5],7,0), s[k1+1][k2-1]+dis(d_data[6*(k2-1)],d_data[6*(k2-1)+1],d_data[6*(k2-1)+2],d_data[6*(k2-1)+3],d_data[6*(k2-1)+4],d_data[6*(k2-1)+5],0,7));
			}
			else if(k1==3)
			{
				s[k1][k2]=comparison(s[k1-2][k2-1]+dis(d_data[6*(k2-1)],d_data[6*(k2-1)+1],d_data[6*(k2-1)+2],d_data[6*(k2-1)+3],d_data[6*(k2-1)+4],d_data[6*(k2-1)+5],0,7), s[k1][k2-1]+dis(d_data[6*(k2-1)],d_data[6*(k2-1)+1],d_data[6*(k2-1)+2],d_data[6*(k2-1)+3],d_data[6*(k2-1)+4],d_data[6*(k2-1)+5],7,0));
			}
		}
	}
    
	if((s[0][(THENUMBEROFDATA+1)]+dis(d_data[6*(THENUMBEROFDATA+1)],d_data[6*(THENUMBEROFDATA+1)+1],d_data[6*(THENUMBEROFDATA+1)+2],d_data[6*(THENUMBEROFDATA+1)+3],d_data[6*(THENUMBEROFDATA+1)+4],d_data[6*(THENUMBEROFDATA+1)+5],0,0))==comparison(s[0][(THENUMBEROFDATA+1)]+dis(d_data[6*(THENUMBEROFDATA+1)],d_data[6*(THENUMBEROFDATA+1)+1],d_data[6*(THENUMBEROFDATA+1)+2],d_data[6*(THENUMBEROFDATA+1)+3],d_data[6*(THENUMBEROFDATA+1)+4],d_data[6*(THENUMBEROFDATA+1)+5],0,0) , s[2][(THENUMBEROFDATA+1)]+dis(d_data[6*(THENUMBEROFDATA+1)],d_data[6*(THENUMBEROFDATA+1)+1],d_data[6*(THENUMBEROFDATA+1)+2],d_data[6*(THENUMBEROFDATA+1)+3],d_data[6*(THENUMBEROFDATA+1)+4],d_data[6*(THENUMBEROFDATA+1)+5],7,7)))
	{
		c[(THENUMBEROFDATA+1)] = 0;
		decode_data[(THENUMBEROFDATA-1)]=0;
	}
	else 
	{
		c[(THENUMBEROFDATA+1)] = 2;
		decode_data[(THENUMBEROFDATA-1)]=0;
	}
	for (l1=(THENUMBEROFDATA+1);l1>=1;l1--)
	{
		if (c[l1]==0)
		{
			if((s[0][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],0,0))==comparison(s[0][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],0,0),s[2][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],7,7)))
			{
				c[l1-1] = 0;
				decode_data[l1-1]=0;
			}
			else 
			{
				c[l1-1] = 2;
				decode_data[l1-1]=0;
			}
		}else if(c[l1]==1)
		{
			if((s[0][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],7,7))==comparison(s[0][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],7,7),s[2][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],0,0)))
			{
				c[l1-1] = 0;
				decode_data[l1-1]=1;
			}
			else 
			{
				c[l1-1] = 2;
				decode_data[l1-1]=1;
			}
		}else if(c[l1]==2)
		{
			if((s[1][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],7,0))==comparison(s[1][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],7,0),s[3][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],0,7)))
			{
				c[l1-1] = 1;
				decode_data[l1-1]=0;
			}
			else 
			{
				c[l1-1] = 3;
				decode_data[l1-1]=0;
			}
		}else if(c[l1]==3)
		{
			if((s[1][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],0,7))==comparison(s[1][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],0,7),s[3][l1-1]+dis(d_data[6*(l1-1)],d_data[6*(l1-1)+1],d_data[6*(l1-1)+2],d_data[6*(l1-1)+3],d_data[6*(l1-1)+4],d_data[6*(l1-1)+5],7,0)))
			{
				c[l1-1] = 1;
				decode_data[l1-1]=1;
			}
			else 
			{
				c[l1-1] = 3;
				decode_data[l1-1]=1;
			}
		}
	}
	/*
		for(l=0;l<=THENUMBEROFDATA+1;l++)
		{
			printf("%d ",c[l]);
		}
	printf("\n");
	
	for(i=0;i<=3;i++)
	{
		for(l=0;l<=THENUMBEROFDATA+2;l++)
		{
			printf("%d",s[i][l]);	
		}
		printf("\n");
	}*/	
}

double comparison(double com1, double com2)
{
	double com3;
	if(com1>=com2)
	{
		com3=com2;
	}else
	{
		com3=com1;
	}
	return (com3);
}

double dis(int data, int data1, int data2, int data3, int data4, int data5, int value1, int value2)
{
	double distance;
	distance = sqrt(pow(((data*4+data1*2+data2)-value1),2) + pow(((data3*4+data4*2+data5)-value2),2));
	return (distance);
}