天线选择定点算法Word文档格式.docx
《天线选择定点算法Word文档格式.docx》由会员分享，可在线阅读，更多相关《天线选择定点算法Word文档格式.docx（19页珍藏版）》请在冰豆网上搜索。
由于接收到的midamble也是经过AGC的，且信道估计是在频域进行，而接收机这端FFT运算也没有归一化，会对信号有个放大，从仿真结果看放大倍数在
左右，没有作大量的统计仿真，观察了几组数据，选择用
来作为估算结果。
综合考虑发送端、接收端的IFFT、FFT和AGC的影响，估计得到的频域信道和实际频域信道间的关系为：
以及算法中估算的结果，公式
（2）变为以下形式：
（3）
二、定点算法中各个模块及各变量位宽设置
有了上述结果，下面给出天线选择各个模块的定点化程序。
2.1噪声功率谱密度计算
通过估计得到的噪声功率谱密度及其位宽设置为：
位宽为（18,18），当
的变换范围为：
0~30dB的时候，估算得到的
的浮点数值范围为（0.0000488281,0.0488281）
通过查表法求得其倒数为：
位宽为（18,2）
2.2天线选择模块
变量名
位宽
说明
h_ch
（18,10）
频域信道
N
整数32
用了32个导频上的信道
var_inverse
（18,2）
噪声功率谱的倒数
nr
4
接收天线数
h_eff
（18,8）
计算的有效信道
h_eff*（h_eff）’
（18,4）
有效信道和它自己的共轭转置的乘积
matrixA
（18，6）
公式
（2）中的矩阵A
det
矩阵的行列式
temp_capa_fix
（11,7）
行列式的对数
capacity
（16,7）
容量值
voidP_rank_cal（P_Complex*h_ch,//输入的信道矩阵
intinput_w,intinput_w_d,//信道矩阵位宽（18,10）
intN,//天线选择中所选用的子载波数
FIXvar_inverse,//信道矩阵位宽（18,10）
intvar_w,intvar_w_d,//噪声功率谱密度的倒数位宽（18,2）
int*mimo_indicator,//计算得到的mimo索引值
intnr）//接收天线数
{
inteff_nt,i,j,k,nr_idx,nt_idx,mimo_idx;
inth_eff_w=input_w;
//计算有效信道位宽和输入总位宽一致，
inth_eff_w_d=input_w_d-2;
//有效信道小数位宽减两位，分两位计入整数位宽
intmatrix_a_w=18;
//H’*H得到的矩阵的总位宽，统一为18
intmatrix_a_w_d=4;
//H’*H得到的矩阵的小数位宽，统一为4
intmatrix_adjust2_a_w=18;
//公式
（2）中计算后的总位宽
intmatrix_adjust2_a_w_d=6;
//公式
（2）中计算后的总小数位宽
intdet_w=18;
//算得的行列式位宽
intdet_w_d=8;
//算得的行列式小数位宽
FIXdet=0;
FIXtemp=0;
FIXtmp1,tmp2;
FIX*temp_capa_fix=（FIX*）malloc（sizeof（FIX））;
//对每个载波计算算得的容量，最后要累加到变量capacity中，共32个累加量（N）
inttemp_capa_fix_w=11;
//每个累加量的总位宽
inttemp_capa_fix_w_d=7;
//每个累加量的小数位宽
FIXcapacity[4];
//现在只计算天线独立数为1和4时的容量，每个位宽为（16,7），由32个temp_capa_fix累加得到
intcapacity_w=16;
intcapacity_w_d=7;
/*****************************************************************************
所需变量空间分配，可以不管
*****************************************************************************/
P_Complex***h_matrix,***h_eff,*h_subcarr,*h_subcarr_Htranspose,*matrixA,tmp;
h_eff=alloc_mem_P_complex3（N,nr,4）;
h_subcarr=alloc_mem_P_complex1（nr*4）;
h_subcarr_Htranspose=alloc_mem_P_complex1（4*nr）;
matrixA=alloc_mem_P_complex1（4*4）;
memset（capacity,0,sizeof（FIX）*4）;
//mimo_index<
4
for（mimo_idx=0;
mimo_idx<
4;
mimo_idx+=3）//mimo_index<
{
/*利用函数P_eff_ch_cal和输入的h_ch来计算对应于不同mimo_idx下的有效信道*/
P_eff_ch_cal（h_ch,input_w,input_w_d,N,mimo_idx,h_eff,h_eff_w,h_eff_w_d,&
eff_nt,nr）;
for（k=0;
k<
N;
k++）
{
/*每次提取一个载波上的有效信道矩阵到变量h_subcarr中,即公式
（2）中的Hi*/
h_subcarrh_eff[k*nr_idx*nt_idx];
/*求Hi共轭转置Hi’*/
P_Htranspose（h_subcarr,nr,eff_nt,h_subcarr_Htranspose,1）;
/*矩阵相乘:
Hi*Hi’*/
P_Matrix_Multiply（matrixA,h_subcarr_Htranspose,h_subcarr,h_eff_w,h_eff_w_d,matrix_a_w,matrix_a_w_d,eff_nt,eff_nt,nr）;
/*求行列式对应的矩阵,即公式
（2）中的矩阵，由于有效天线数为1的时候，要对计算得到的矩阵除以2^18，而有效天线数为4时，要除以2^20，所以此处将分根据有效天线数的不同，对
（2）中矩阵的计算分开来处理，但是最终结果都是保存为（18，6）*/
if（eff_nt==1）
{
for（i=0;
i<
eff_nt;
i++）
{
for（j=0;
j<
j++）
{
tmp1=Multiply（（matrixA+i*eff_nt+j）->
re,var_inverse）;
tmp2=Multiply（（matrixA+i*eff_nt+j）->
im,var_inverse）;
（matrixA+i*eff_nt+j）->
re=AdjustFIX（tmp1>
>
18,36,6,matrix_adjust2_a_w,matrix_adjust2_a_w_d）;
im=AdjustFIX（tmp2>
if（i==j）
re=（matrixA+i*eff_nt+j）->
re+Tofixed（1,matrix_adjust2_a_w,matrix_adjust2_a_w_d）;
}
}
}
elseif（eff_nt==4）
20,36,6,matrix_adjust2_a_w,matrix_adjust2_a_w_d）;
/*求行列式*/
det=P_Matrix_Determinant（matrixA,eff_nt,matrix_adjust2_a_w,matrix_adjust2_a_w_d,det_w,det_w_d）;
if（det.re<
Tofixed（1,det_w,det_w_d））//calculationprotection
det.re=Tofixed（1,det_w,det_w_d）;
*temp_capa_fix=0;
/*查表法求对数*/
LOG2FORFIX（tmp.re,det_w,det_w_d,temp_capa_fix,temp_capa_fix_w,temp_capa_fix_w_d）;
/*计算得到的容量累积*/
capacity[mimo_idx]=Add（AdjustFIX（*temp_capa_fix,temp_capa_fix_w,temp_capa_fix_w_d,capacity_w,capacity_w_d）,capacity[mimo_idx]）;
}
/*选择最大容量的天线配置为系统下一帧的天线数*/
mimo_idx++）
if（capacity[mimo_idx]>
temp）
temp=capacity[mimo_idx];
*mimo_indicator=mimo_idx;
}
2.3各个子模块
2.3.1有效信道计算模块
根据输入的mimo_index值来计算有效信道
输入、输出参数位宽参见上一节。
不管信道是几维的，4*4还是1*1，最终都将位宽调整为（18,8）。
voidP_eff_ch_cal（P_Complex***h_ch,intinput_w,intinput_w_d,intN,intmimo_index,P_Complex***h_eff,inth_eff_w,inth_eff_w_d,int*eff_nt,intnr）
intnt_idx,nr_idx,k;
P_Complext1,t2;
/*分别根据输入的mimo_index不同，对频域信道矩阵做不同处理*/
if（mimo_index==0）
for（nt_idx=0;
nt_idx<
nt_idx++）
for（nr_idx=0;
nr_idx<
nr;
nr_idx++）
for（k=0;
h_eff[k][nr_idx][nt_idx]=AdjustPC（h_ch[k][nr_idx][nt_idx],input_w,input_w_d,h_eff_w,h_eff_w_d）;
*eff_nt=4;
//mimo_index为1时，0、1两根天线上的数据相加
elseif（mimo_index==1）
{
{h_eff[k][nr_idx][0]=P_Complex_Add（h_ch[k][nr_idx][0],h_ch[k][nr_idx][1]）;
h_eff[k][nr_idx][0]=AdjustPC（h_eff[k][nr_idx][0],input_w+1,input_w_d,h_eff_w,h_eff_w_d）;
h_eff[k][nr_idx][1]=AdjustPC（h_ch[k][nr_idx][2],input_w,input_w_d,h_eff_w,h_eff_w_d）;
h_eff[k][nr_idx][2]=AdjustPC（h_ch[k][nr_idx][3],input_w,input_w_d,h_eff_w,h_eff_w_d）;
}
*eff_nt=3;
//mimo_index为1时，0,1两根天线上的数据相加，2、3两根天线上的数据相加
elseif（mimo_index==2）//mimo_index=7
h_eff[k][nr_idx][0]=P_Complex_Add（h_ch[k][nr_idx][0],h_ch[k][nr_idx][1]）;
h_eff[k][nr_idx][0]=AdjustPC（h_eff[k][nr_idx][0],input_w+1,input_w_d,h_eff_w,h_eff_w_d）;
h_eff[k][nr_idx][1]=P_Complex_Add（h_ch[k][nr_idx][2],h_ch[k][nr_idx][3]）;
h_eff[k][nr_idx][1]=AdjustPC（h_eff[k][nr_idx][1],input_w+1,input_w_d,h_eff_w,h_eff_w_d）;
*eff_nt=2;
//mimo_index为1时，0,1，2、3两根天线上的数据相加
elseif（mimo_index==3）//mimo_index=10
t1=P_Complex_Add（h_ch[k][nr_idx][0],h_ch[k][nr_idx][1]）;
t2=P_Complex_Add（h_ch[k][nr_idx][2],h_ch[k][nr_idx][3]）;
h_eff[k][nr_idx][0]=P_Complex_Add（t1,t2）;
h_eff[k][nr_idx][0]=AdjustPC（h_eff[k][nr_idx][0],input_w+2,input_w_d,h_eff_w,h_eff_w_d）;
*eff_nt=1;
else
printf（"
Wrongmimo_indexineff_ch_cal.c\n"
）;
return;
2.3.2矩阵相乘
矩阵matrixB和矩阵matrixC相乘，并将结果保存在matrixA中
matrixB
在调用的时候为信道矩阵Hi
matrixC
Hi的共轭转置
Hi*Hi’
voidP_Matrix_Multiply（P_Complex*matrixA,
P_Complex*matrixB,
P_Complex*matrixC,
intinput_w,
intinput_w_d,
intmatrix_a_w,
intmatrix_a_w_d,
introw,
intcolumn,
intsame_parameter
）
//FILE*fptest=fopen（"
f:
\\fix.txt"
"
at+"
inti,j,k;
P_Complex*move_pointerA;
constP_Complex*move_pointerB;
constP_Complex*move_pointerC;
memset（matrixA,0,sizeof（P_Complex）*row*column）;
for（i=0;
row;
move_pointerB=matrixB+i*same_parameter;
for（j=0;
column;
move_pointerA=matrixA+i*column+j;
move_pointerC=matrixC+j;
for（k=0;
same_parameter;
*move_pointerA=P_Complex_Add（*move_pointerA,P_Complex_Multiply（*（move_pointerB+k）,*（move_pointerC+k*column）））;
}
*move_pointerA=AdjustPC（*move_pointerA,input_w*2+2,input_w_d*2,matrix_a_w,matrix_a_w_d）;
2.3.3矩阵行列式
行列式是用递归的方法来求，递归过程中所有中间结果位宽统一调整为（18,8）
P_ComplexP_Matrix_Determinant（P_Complex*matrix,
inteff_nt,
intinput_w,
intinput_w_d,
intdet_w,
intdet_w_d）
P_Complex*matrixA=matrix;
P_Complexdeterminant;
//根据有效信道数来确定矩阵的维数
switch（eff_nt）
case1:
determinant=AdjustPC（*matrixA,input_w,input_w_d,det_w,det_w_d）;
break;
case2:
determinant=P_Matrix_Determinant_Two（matrixA,input_w,input_w_d,det_w,det_w_d）;
case3:
determinant=P_Matrix_Determinant_Three（matrixA,input_w,input_w_d,det_w,det_w_d）;
case4:
determinant=P_Matrix_Determinant_Four（matrixA,input_w,input_w_d,det_w,det_w_d）;
returndeterminant;
//N=column二阶行列式,对角线相乘得到
P_ComplexP_Matrix_Determinant_Two（P_Complex*matrix,
intinput_w,
intinput_w_d,
intdet_w,
intdet_w_d）
P_Complexdeterminant={0,0};
P_Complextemp1,temp2;
temp1=P_Complex_Multiply（*（matrix）,*（matrix+3））;
temp2=P_Complex_Multiply（*（matrix+1）,*（matrix+2））;
determinant=P_Complex_Minus（temp1,temp2）;
//调整行列式位宽为啊（18,8）
determinant=AdjustPC（determinant,input_w*2,input_w_d*2,det_w,det_w_d）;
return（determinant）;
//N=column三阶行列式,利用二阶行列数递归得到
P_ComplexP_Matrix_Determinant_Three（P_Complex*matrix,
intinput_w,
intinput_w_d,
intdet_w,
intdet_w_d）
inti;
intN=3;
P_Complextmp;
P_Complex*matrix_part;
matrix_part=（P_C
升级会员 