main.c

一些关于Turbo编码译码实现所需的函数和原程序。

/*----------------------------------------------------------
* Copyright (c) 2003, 北京邮电大学移动通信实验室
* All rights reserved.
*
* 文件名称：main.c
* 文件标识：
* 摘    要：Turbo仿真主程序.
*
* 当前版本：1.0
* 作    者：张鹏
* 完成日期：2003年12月1日
----------------------------------------------------------*/
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>

/*==================================================*/
#include "turbo_code_Log_MAP.h"
#include "turbo_other_functions.h"
/*==================================================*/



/*==================================================*/
extern double rate_coding;
extern TURBO_G turbo_g;
extern double *alpha_channel;
extern int M_num_reg;
extern double time_jarks;
/*==================================================*/

void main()
{
	int *trafficflow_sourceA = NULL;
	int *trafficflow_decodedA =NULL;
	float *coded_trafficflow_source1A =NULL;
	float *coded_trafficflow_source2A = NULL;
	float *coded_trafficflowA = NULL;
	float *trafficflow_for_decodeA = NULL;
	int *rsc1A = NULL;
	int *rsc2A = NULL;
	int *interleaved_trafficflowA=NULL;
	
	int *trafficflow_sourceB = NULL;
	int *trafficflow_decodedB =NULL;
	float *coded_trafficflow_source1B =NULL;
	float *coded_trafficflow_source2B = NULL;
	float *coded_trafficflowB = NULL;
	float *trafficflow_for_decodeB = NULL;
	int *rsc1B = NULL;
	int *rsc2B = NULL;
	int *interleaved_trafficflowB=NULL;
	
	int traffic_source_length;
	int	trafficflow_lengthA;
	int	trafficflow_lengthB;
	int err_bit_num_traffic[8];
	int frame_limit = 100;
	int i,ien,nf;
	double en, sgma;
	double fd_rayleigh = 10;
	double fs_rayleigh = FRAME_LENGTH*100;
	float EbN0dB=0;
//	double Eb_N0_dB[8] = {0.0, 1, 2, 3, 4, 5, 6, 7};
//	double Eb_N0_dB[8] = {0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3, 3.5};
//	double Eb_N0_dB[8] = {0.0, 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1};
	double Eb_N0_dB[8] = {0, 5, 10, 15, 20, 25, 30, 35};
	int error_limit[8] = {1000, 1000, 500, 300, 200, 100, 50, 20};
	double err_bit_rate_traffic[8];
	if ((trafficflow_sourceA=(int *)malloc(FRAME_LENGTH*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of trafficflow_source1 \n");
	  exit(1);  
	}
	if ((trafficflow_decodedA=(int *)malloc(FRAME_LENGTH*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of trafficflow_source1 \n");
	  exit(1);  
	}
	if ((coded_trafficflow_source1A=(float *)malloc(2*(FRAME_LENGTH + M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}

	if ((coded_trafficflow_source2A=(float *)malloc((FRAME_LENGTH + 2*M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}
	if ((trafficflow_for_decodeA=(float *)malloc((3*FRAME_LENGTH+4*M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}
	if ((coded_trafficflowA=(float *)malloc((3*FRAME_LENGTH+4*M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}
	if ((rsc1A=(int *)malloc(2*(FRAME_LENGTH + M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}

	if ((rsc2A=(int *)malloc(2*(FRAME_LENGTH + M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}

	if ((interleaved_trafficflowA=(int *)malloc(FRAME_LENGTH*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of input2 \n");
	  exit(1);  
	}
	if ((trafficflow_sourceB=(int *)malloc(FRAME_LENGTH*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of trafficflow_source1 \n");
	  exit(1);  
	}
	if ((trafficflow_decodedB=(int *)malloc(FRAME_LENGTH*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of trafficflow_source1 \n");
	  exit(1);  
	}
	if ((coded_trafficflow_source1B=(float *)malloc(2*(FRAME_LENGTH + M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}

	if ((coded_trafficflow_source2B=(float *)malloc((FRAME_LENGTH +2*M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}
	if ((trafficflow_for_decodeB=(float *)malloc((3*FRAME_LENGTH+4*M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}
	if ((coded_trafficflowB=(float *)malloc((3*FRAME_LENGTH+4*M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}
	if ((rsc1B=(int *)malloc(2*(FRAME_LENGTH + M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}

	if ((rsc2B=(int *)malloc(2*(FRAME_LENGTH + M_num_reg)*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of rsc2 \n");
	  exit(1);  
	}

	if ((interleaved_trafficflowB=(int *)malloc(FRAME_LENGTH*sizeof(int)))==NULL)
	{
	  printf("\n fail to allocate memory of input2 \n");
	  exit(1);  
	}
	if ((alpha_channel=(double *)malloc((3*FRAME_LENGTH+4*M_num_reg)*sizeof(double)))==NULL)
	{
	  printf("\n fail to allocate memory of supflow_decoded\n");
	  exit(1);  
	}
srand((unsigned)time(NULL));	
/*-----------------------------------------------------------------*/	
/*-----------------------------------------------------------------*/
	TurboCodingInit();
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/	
	for (ien=0; ien<8; ien++)
	{
		EbN0dB=(float)Eb_N0_dB[ien];
		en = (float)pow(10,EbN0dB/10);
		sgma = (float)(1.0/sqrt(2*en/3));
		err_bit_num_traffic[ien]=0;

		time_jarks=(double)(rand()*100000%RAND_MAX)*500*(1/fs_rayleigh);
		traffic_source_length = FRAME_LENGTH;
		for (nf=0; err_bit_num_traffic[ien]<error_limit[ien]; nf++)
//		for (nf=0; nf<2; nf++)
	{	
		//生成信源序列	
		gen_source(trafficflow_sourceA, traffic_source_length);
		gen_source(trafficflow_sourceB, traffic_source_length);
		
		//RSC编码
		rsc_encode(trafficflow_sourceA,rsc1A,1,traffic_source_length);
		rsc_encode(trafficflow_sourceB,rsc1B,1,traffic_source_length);
		
		//生成随机交织器
		gen_rand_index(traffic_source_length, 1);

		//交织
		interleave_int(trafficflow_sourceA, interleaved_trafficflowA, TYPE_INTERLEAVER, traffic_source_length, 1);
		interleave_int(trafficflow_sourceB, interleaved_trafficflowB, TYPE_INTERLEAVER, traffic_source_length, 1);
		
		//将交织后的序列编码
		rsc_encode(interleaved_trafficflowA, rsc2A, 1, traffic_source_length);
		rsc_encode(interleaved_trafficflowB, rsc2B, 1, traffic_source_length);
		
		//合并发送的序列
		for (i=0; i<FRAME_LENGTH; i++)
		{
			*(coded_trafficflow_source1A+2*i) = (float) *(rsc1A+2*i);
			*(coded_trafficflow_source1A+2*i+1) = (float) *(rsc1A+2*i+1);
			*(coded_trafficflow_source2A+i) = (float) *(rsc2A+2*i+1);
			
			*(coded_trafficflow_source1B+2*i) = (float) *(rsc1B+2*i);
			*(coded_trafficflow_source1B+2*i+1) = (float) *(rsc1B+2*i+1);
			*(coded_trafficflow_source2B+i) = (float) *(rsc2B+2*i+1);		
		
		}	
		
		for (i=0; i<2*M_num_reg; i++)
		{
			*(coded_trafficflow_source1A+2*FRAME_LENGTH + i) = (float) *(rsc1A+2*FRAME_LENGTH+i);
			*(coded_trafficflow_source1B+2*FRAME_LENGTH + i) = (float) *(rsc1B+2*FRAME_LENGTH+i);
			*(coded_trafficflow_source2A+FRAME_LENGTH + i) = (float) *(rsc2A+2*FRAME_LENGTH+i);
			*(coded_trafficflow_source2B+FRAME_LENGTH + i) = (float) *(rsc2B+2*FRAME_LENGTH+i);
		}

		//bpsk调制
		for (i=0; i<FRAME_LENGTH; i++)
		{
			*(coded_trafficflowA+3*i) = *(coded_trafficflow_source1A+2*i) *2 - 1;
			*(coded_trafficflowA+3*i+1) = *(coded_trafficflow_source1A+2*i+1) *2 - 1;
			*(coded_trafficflowA+3*i+2) = *(coded_trafficflow_source2A+i) *2 - 1;
			
			*(coded_trafficflowB+3*i) = *(coded_trafficflow_source1B+2*i) *2 - 1;
			*(coded_trafficflowB+3*i+1) = *(coded_trafficflow_source1B+2*i+1) *2 - 1;
			*(coded_trafficflowB+3*i+2) = *(coded_trafficflow_source2B+i) *2 - 1;		
		
		}
	
		for (i=0; i<2*M_num_reg; i++)
		{
			*(coded_trafficflowA+3*FRAME_LENGTH+i) = *(coded_trafficflow_source1A+2*FRAME_LENGTH+i) *2 - 1;
			*(coded_trafficflowA+3*FRAME_LENGTH+2*M_num_reg+i) = *(coded_trafficflow_source2A+FRAME_LENGTH+i)*2 - 1;
			
			*(coded_trafficflowB+3*FRAME_LENGTH+i) = *(coded_trafficflow_source1B+2*FRAME_LENGTH+i) *2 - 1;
			*(coded_trafficflowB+3*FRAME_LENGTH+2*M_num_reg+i) = *(coded_trafficflow_source2B+FRAME_LENGTH+i)*2 - 1;
		
		}	

		//生成信道
		if(TYPE_CHANNEL)
		{
			chan_jakes(alpha_channel, fd_rayleigh, fs_rayleigh,3*FRAME_LENGTH+4*M_num_reg);
		}
		else
		{
			for (i=0; i<(3*FRAME_LENGTH+4*M_num_reg); i++)
			{
				*(alpha_channel+i) = 1;
			}
		}

		//调制后的序列通过信道
		rayleigh_channel_1226(coded_trafficflowA, trafficflow_for_decodeA, sgma, 3*FRAME_LENGTH+4*M_num_reg);
		rayleigh_channel_1226(coded_trafficflowB, trafficflow_for_decodeB, sgma, 3*FRAME_LENGTH+4*M_num_reg);
			
		trafficflow_lengthA = 3*FRAME_LENGTH+4*M_num_reg;
		trafficflow_lengthB = 3*FRAME_LENGTH+4*M_num_reg;
		
		//解码
		TurboDecodingTraffic(trafficflow_for_decodeA, trafficflow_decodedA,&trafficflow_lengthA, EbN0dB);
		TurboDecodingTraffic(trafficflow_for_decodeB, trafficflow_decodedB,&trafficflow_lengthB, EbN0dB);

		//计算BER
		for (i=0; i<FRAME_LENGTH; i++)
		{
			if (*(trafficflow_sourceA+i) != *(trafficflow_decodedA+i))
			{
				err_bit_num_traffic[ien] = err_bit_num_traffic[ien]+1;
			}
			if (*(trafficflow_sourceB+i) != *(trafficflow_decodedB+i))
			{
				err_bit_num_traffic[ien] = err_bit_num_traffic[ien]+1;
			}		
		}
	}
		err_bit_rate_traffic[ien] = (double)err_bit_num_traffic[ien]/(2*nf*FRAME_LENGTH);
		printf("Eb/N0= %f db\n",EbN0dB);
		printf("BER= %f\n",err_bit_rate_traffic[ien]);
		printf("///////////////////////////////////////\n");
	}
	TurboCodingRelease();
	free(trafficflow_sourceA);
	free(trafficflow_decodedA);
	free(coded_trafficflow_source1A);
	free(coded_trafficflow_source2A);
	free(coded_trafficflowA);
	free(trafficflow_for_decodeA);
	free(interleaved_trafficflowA);
	free(rsc1A);
	free(rsc2A);	

	free(trafficflow_sourceB);
	free(trafficflow_decodedB);
	free(coded_trafficflow_source1B);
	free(coded_trafficflow_source2B);
	free(coded_trafficflowB);
	free(trafficflow_for_decodeB);
	free(interleaved_trafficflowB);
	free(rsc1B);
	free(rsc2B);
	free(alpha_channel);
}