viterbiqpskinrayleigh.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, 3)
#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);
int comparison(int com1, int com2);
void viterbi_decode(int *d_data, int *decode_data);


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 er_data;
	complex H;
	int d_data[2*(THENUMBEROFDATA+2)];
	int decode_data[THENUMBEROFDATA+2];
	int error;
	//int error1;
	double avgerr;
	int EbofN0;
//	int viter;
	// open the file 
	fp1=fopen("result_qpsk_ViterbiRayleigh.txt","w");
	srand(time(0));

	
	for(EbofN0=11; EbofN0<=15; EbofN0+=1)
	{
		double sumerr=0;
		int run;		
	    int i;
		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)*(H.real*m_data.real-H.imag*m_data.imag) + Noise.real;
			    r_data.imag = sqrt(1.0/2.0)*(H.real*m_data.imag+H.imag*m_data.real) + 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
			    d_data[2*i] = (int)demodulation(er_data.real);
			    d_data[2*i+1] = (int)demodulation(er_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(d_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 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)
{
	int 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]=9;
		}
	}
    s[0][0]=0;
	s[0][1]=(d_data[0]^0)+(d_data[1]^0);
	s[1][1]=(d_data[0]^1)+(d_data[1]^1);
	s[0][2]=s[0][1]+(d_data[2]^0)+(d_data[3]^0);
	s[1][2]=s[0][1]+(d_data[2]^1)+(d_data[3]^1);
	s[2][2]=s[1][1]+(d_data[2]^1)+(d_data[3]^0);
	s[3][2]=s[1][1]+(d_data[2]^0)+(d_data[3]^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]+(d_data[2*(k2-1)]^0)+(d_data[2*(k2-1)+1]^0), s[k1+2][k2-1]+(d_data[2*(k2-1)]^1)+(d_data[2*(k2-1)+1]^1));
			}
			else if(k1==1)
			{
				s[k1][k2]=comparison(s[k1-1][k2-1]+(d_data[2*(k2-1)]^1)+(d_data[2*(k2-1)+1]^1), s[k1+1][k2-1]+(d_data[2*(k2-1)]^0)+(d_data[2*(k2-1)+1]^0));
			}
			else if(k1==2)
			{
				s[k1][k2]=comparison(s[k1-1][k2-1]+(d_data[2*(k2-1)]^1)+(d_data[2*(k2-1)+1]^0), s[k1+1][k2-1]+(d_data[2*(k2-1)]^0)+(d_data[2*(k2-1)+1]^1));
			}
			else if(k1==3)
			{
				s[k1][k2]=comparison(s[k1-2][k2-1]+(d_data[2*(k2-1)]^0)+(d_data[2*(k2-1)+1]^1), s[k1][k2-1]+(d_data[2*(k2-1)]^1)+(d_data[2*(k2-1)+1]^0));
			}
		}
	}
    
	if((s[0][(THENUMBEROFDATA+1)]+(d_data[2*(THENUMBEROFDATA+1)]^0)+(d_data[2*(THENUMBEROFDATA+1)+1]^0))==comparison(s[0][(THENUMBEROFDATA+1)]+(d_data[2*(THENUMBEROFDATA+1)]^0)+(d_data[2*(THENUMBEROFDATA+1)+1]^0) , s[2][(THENUMBEROFDATA+1)]+(d_data[2*(THENUMBEROFDATA+1)]^1)+(d_data[2*(THENUMBEROFDATA+1)+1]^1)))
	{
		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]+(d_data[2*(l1-1)]^0)+(d_data[2*(l1-1)+1]^0))==comparison(s[0][l1-1]+(d_data[2*(l1-1)]^0)+(d_data[2*(l1-1)+1]^0),s[2][l1-1]+(d_data[2*(l1-1)]^1)+(d_data[2*(l1-1)+1]^1)))
			{
				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]+(d_data[2*(l1-1)]^1)+(d_data[2*(l1-1)+1]^1))==comparison(s[0][l1-1]+(d_data[2*(l1-1)]^1)+(d_data[2*(l1-1)+1]^1),s[2][l1-1]+(d_data[2*(l1-1)]^0)+(d_data[2*(l1-1)+1]^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]+(d_data[2*(l1-1)]^1)+(d_data[2*(l1-1)+1]^0))==comparison(s[1][l1-1]+(d_data[2*(l1-1)]^1)+(d_data[2*(l1-1)+1]^0),s[3][l1-1]+(d_data[2*(l1-1)]^0)+(d_data[2*(l1-1)+1]^0)))
			{
				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]+(d_data[2*(l1-1)]^0)+(d_data[2*(l1-1)+1]^1))==comparison(s[1][l1-1]+(d_data[2*(l1-1)]^0)+(d_data[2*(l1-1)+1]^1),s[3][l1-1]+(d_data[2*(l1-1)]^1)+(d_data[2*(l1-1)+1]^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");
	}*/
	
}

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