interleaving.c

基于MATLAB的GSM仿真系统 并附有直接画出性能曲线的简化程序。

/*********************************************************************
* 文件名称： Interleaving.c
* 主要内容： 说明文件的内容，完成的功能，文件中包括哪些主要模块、函数等
*=====================================================================
* 版权所有 (C)2004, 东南大学移动通信国家重点实验室。
* 
* 当前版本： 0.2.0
* 作    者： 王艳
* 完成日期： 2004年5月17日
*=====================================================================
* 其它说明： 其它需要内容的说明（如没有则不写）
*=====================================================================
* 修改概述
*
* 修改记录1：// 修改历史记录，包括修改日期、修改者及修改内容
*    修改日期：
*    版 本 号：
*    修 改 人：
*    修改内容： 
*
* 修改记录2：…
**********************************************************************/
#include "Interleaving.h"




//interleaving_table table[Ninterleave];  //定义表
//int c[Iinterleave*Ninterleave];                   //输入已卷积的数据流
//int i[(Iinterleave+1)*Ninterleave];               //输出已交织的数据流
//int e[(Iinterleave+1)*4*148];           //输出映射后的数据流

/*******************************************************************
函数说明：
函数名：create_table
函数功能：产生交织表
输入：无
    
输出：利用参数，生成交织地址表，以k为地址，其对应的B，j为表中的内容
********************************************************************/
void create_table(interleaving_table table[Ninterleave])
{
	int k;
	for (k=0;k<=Ninterleave-1;k++)
	{
		table[k].B=k % 8;                           //利用k求B
		table[k].j=2*((49*k) % 57)+((k % 8) / 4);   //利用k求j
		//printf("%d",k);
		//printf("%5d",table[k].B);
		//printf("%5d\n",table[k].j);
	}

}


/***********************************
函数说明：
函数名：interleaving
函数功能：交织
输入：Ninterleave*Iinterleave
    
输出：Ninterleave*(Iinterleave+1)
    
************************************/
void interleaving (int c[],int i[],interleaving_table table[Ninterleave])
{
	int m;        //循环变量，能遍历输入数组
	int b;        //burst序号
	int k;        //由m算出对应的k，作为查表地址
	int n;        //由m计算bolck的序号
	for (m=0;m<(Iinterleave+1)*Ninterleave;m++)
		i[m]=0;
	for (m=0;m<Iinterleave*Ninterleave;m++)
	{
		k=m % Ninterleave;
		n=m / Ninterleave;
		b=4*n+table[k].B;
		i[b*114+table[k].j]=c[m];
	}
}



/***********************************
函数说明：
函数名：mapping_1
函数功能：映射
输入：Ninterleave*(Iinterleave+1)
    
输出：(Ninterleave+8)*(Iinterleave+1)
    
************************************/
/*
mapping_1(int i[],int e[])
{
	int B=0;
	int j=0;
	for (B=0;B<4*(Iinterleave+1);B++)
	{
		for (j=0;j<57;j++)
		{
			e[B*116+j]=i[B*114+j];
			e[B*116+59+j]=i[B*114+57+j];
		}
		e[B*116+57]=0;
		e[B*116+58]=0;
	}
}
*/



/***********************************
函数说明：
函数名：mapping_2
函数功能：映射出帧结构，输出给调制模块
输入：Ninterleave*(Iinterleave+1)
    
输出：148*(Iinterleave+1)*4
    
************************************/
void mapping_2(int i[],int e[])
{
	int B=0;
	int j=0;
	for (B=0;B<4*(Iinterleave+1);B++)
	{
		for (j=0;j<3;j++)        //加Tail bits
		{
			e[B*148+j]=0;
			e[(B+1)*148-(j+1)]=0;
		}
		for (j=0;j<57;j++)       //Message bits
		{
			e[B*148+j+3]=i[B*114+j];
			e[B*148+88+j]=i[B*114+57+j];
		}

		//添加hu(B),hi(B)
		e[B*148+60]=0;
		e[B*148+87]=0;

		//添加训练序列
		e[B*148+61]=0;
		e[B*148+62]=0;
		e[B*148+63]=1;
		e[B*148+64]=0;
		e[B*148+65]=0;
		e[B*148+66]=1;
		e[B*148+67]=0;
		e[B*148+68]=1;
		e[B*148+69]=1;
		e[B*148+70]=1;
		e[B*148+71]=0;
		e[B*148+72]=0;
		e[B*148+73]=0;
		e[B*148+74]=0;
		e[B*148+75]=1;
		e[B*148+76]=0;
		e[B*148+77]=0;
		e[B*148+78]=0;
		e[B*148+79]=1;
		e[B*148+80]=0;
		e[B*148+81]=0;
		e[B*148+82]=1;
		e[B*148+83]=0;
		e[B*148+84]=1;
		e[B*148+85]=1;
		e[B*148+86]=1;
	}
}


		

//主函数
/*void main()
{
	int a;
	//初始化输入序列
	for (a=0;a<Iinterleave*Ninterleave;a++)
	{
		c[a]=a % 456;
	}
	
	create_table(table);      //调用函数creat_table生成交织表
	interleaving(c,i);        //调用函数interleaving进行交织
	mapping_2(i,e);             //调用函数mapping对交织后的数据映射成需要的格式           
	
	//观测中途输出交织结果
	for (a=0;a<(Iinterleave+1)*Ninterleave;a++)
	{
		printf("%5d",i[a]);
		if ((a % 10)==9) printf("\n");
	}

	//观测输出结果
	printf("\n");
	printf("\n");
	printf("\n");
	printf("输出最终结果，为映射后数据\n");
	for (a=0;a<(Iinterleave+1)*4*148;a++)
	{
		printf("%5d",e[a]);
		if ((a % 10)==9) printf("\n");
	}
}
*/


int jointblock3to1(int block1[Ninterleave],int block2[Ninterleave],
                   int block3[Ninterleave],int blockforinter[Iinterleave*Ninterleave])
{
	int i;
	
	for (i = 0;i<Ninterleave;i++)
	{
		blockforinter[0*Ninterleave+i] = block1[i];
		blockforinter[1*Ninterleave+i] = block2[i];
		blockforinter[2*Ninterleave+i] = block3[i];
	}
	
	return 0;
}