天线选择定点算法.docx
《天线选择定点算法.docx》由会员分享，可在线阅读，更多相关《天线选择定点算法.docx（19页珍藏版）》请在冰豆网上搜索。
天线选择定点算法
天线选择定点算法
一、系统平台与原理算法间的对应关系
在文档[1]中提出，用以下两个公式来对不同天线配置下的信道容量进行遍历式计算，然后通过比较这些容量的大小来确定天线选择方案：
（1）
（2）
其中
为Hermitian矩阵，维数为
（
）。
是第
个参考信号子载波的有效信道矩阵，维数为
。
是总的信号的发送能量（归一化能量发送时取值为1），
是发送流数，
是多个接收天线上的平均噪声方差。
为参与运算的总的子载波信道数目。
在系统算法平台中，发射端的调制信号能量归一化以后，经过IFFT运算后总能量衰减为原来的1/1024，总的信号发送能量没有进行归一化，在对过了多径的信号噪声的时候，噪声功率计算为：
：
多径信道增益
：
平均每个符号的能量，星座点归一化为1
：
发射天线数
:
FFT点数
：
噪声功率谱密度
：
指定的信噪比
：
调制方式
实际加入的噪声是信号的实部和虚部分别加入的，功率谱密度为：
在利用CP或是preamble进行
的估计时，由于是在时域进行的，接收到的信号经过AGC以后会有个AGC的调整因子：
：
AGC调整因子
这样估计到的噪声功率谱密度是
的倍数，倍数关系为：
，即估计得到的噪声功率谱密度：
由于接收到的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
（18,8）
矩阵的行列式
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<4
{
/*利用函数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{
/*每次提取一个载波上的有效信道矩阵到变量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{
for（j=0;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）;
（matrixA+i*eff_nt+j）->im=AdjustFIX（tmp2>>18,36,6,matrix_adjust2_a_w,matrix_adjust2_a_w_d）;
if（i==j）
（matrixA+i*eff_nt+j）->re=（matrixA+i*eff_nt+j）->re+Tofixed（1,matrix_adjust2_a_w,matrix_adjust2_a_w_d）;
}
}
}
elseif（eff_nt==4）
{
for（i=0;i{
for（j=0;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>>20,36,6,matrix_adjust2_a_w,matrix_adjust2_a_w_d）;
（matrixA+i*eff_nt+j）->im=AdjustFIX（tmp2>>20,36,6,matrix_adjust2_a_w,matrix_adjust2_a_w_d）;
if（i==j）
（matrixA+i*eff_nt+j）->re=（matrixA+i*eff_nt+j）->re+Tofixed（1,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{
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]）;
}
}
/*选择最大容量的天线配置为系统下一帧的天线数*/
for（mimo_idx=0;mimo_idx<4;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<4;nt_idx++）
{
for（nr_idx=0;nr_idx{
for（k=0;k{
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）
{
for（nr_idx=0;nr_idx{
for（k=0;k{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
{
for（nr_idx=0;nr_idx{
for（k=0;k{
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
{
for（nr_idx=0;nr_idx{
for（k=0;k{
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
（18,8）
在调用的时候为信道矩阵Hi
matrixC
（18,8）
Hi的共轭转置
matrixA
（18,4）
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;i{
move_pointerB=matrixB+i*same_parameter;
for（j=0;j{
move_pointerA=matrixA+i*column+j;
move_pointerC=matrixC+j;
for（k=0;k{
*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）;
break;
case3:
determinant=P_Matrix_Determinant_Three（matrixA,input_w,input_w_d,det_w,det_w_d）;
break;
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_Complexdeterminant={0,0};
P_Complex*matrix_part;
matrix_part=（P_C
升级会员 