⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 v06_03_dem_2up_arrange.m

📁 Orthogonal frequency offser
💻 M
📖 第 1 页 / 共 4 页
字号:
                               RR(k3_total) = RR(k3_total) + real(c_2(temp_ii)*(c_2(temp_ii))'); % 求相关长度内信号的能量
                           end                                                     
                           
	                       MMd(k3_total) = abs(PP(k3_total));	                      
	                       MMd_Threshold = RR(k3_total)*(17/20);
                           
                           % 将大于一定门限的值记录下来
                           if( MMd(k3_total) > short_tr_threshold*3 )                              
                               if ( MMd(k3_total) >=  MMd_Threshold )                                   
                                   Timing_long_index(t_long) = k3_total;
                                   Timing_long_index_2(t_long) = k3;
                                   
                                   % 寻找最后一个极大值点
                                   if(t_long>2)
                                       if(  (MMd(k3_total-1) >= MMd(k3_total-2)) & (MMd(k3_total-1)>=MMd(k3_total)) )                                          
                                           Timing_long_index_last_total = k3_total - 1;
                                           Timing_long_index_last = k3-1;                                           
                                       end
                                   end                                   
                                   t_long = t_long + 1;                                 
                                   flag_long_index = 1;                                   
                               end % end of "if ( MMd(k3_total) > MMd_Threshold )"
                               
                               
                               % 记录相关值小于门限的次数
                               if( flag_long_index == 1 & MMd(k3_total) < MMd_Threshold )                                   
                                   long_tr_detected = long_tr_detected + 1;
                               end
                               
                               % 当相关值小于门限的次数达到一定的次数,认为第一个长训练字已经完全达到,可以进行FFT窗口位置的估计
                               if(long_tr_detected == 5)
    
                                   symbol_timed = symbol_timed + 1; % 设置信号到达的标志位
                                   
                                   % 认为找到的最后一个极大值点,即为FFT窗口结束的位置
                                   % Timing_index_1是一个与k3_total有关的值,这里使用Timing_index_1是为了便于仿真与测试,在ccs程序中,将全部用k3来计算
                                   % Timing_index_2即是一个与k3有关的值
                                   % Timing_index_1和Timing_index_2都是对FFT位置的表示
                                   
                                   Timing_index_1 = Timing_long_index_last_total; 
                                   
                                   if(Timing_long_index_last==0)
                                       Timing_index_2 = Timing_long_index_last + Ntotal*2*2;
                                   elseif(Timing_long_index_last>0)
                                       Timing_index_2 = Timing_long_index_last;
                                   end
                                                                                                            
                                   % 由于缓冲区中放的是2个OFDN长度的数据,与Timing_index_2还有一个相对应的位置
                                   % Timing_index_3是在缓冲区中与Timing_index_2相对应的位置
                                   if(Timing_index_2 + Ntotal*2 > Ntotal*2*2)											
									    Timing_index_3 = Timing_index_2 - Ntotal*2;                                 
								   else											
                                        Timing_index_3 = Timing_index_2 + Ntotal*2;
                                   end                                 
                                                                                                        
                               end % end of "if(long_tr_detected == 5)"                               
                           end % end of "if( MMd(k3_total) > short_tr_threshold*3 )" 
                           	                       
	                   end % end of if(symbol_timed < 1)
	               end % end of if (short_tr_timed == Times_short_should_find)
	               
	              % 定时估计完成,开始进行数据解调               
	              if(symbol_timed == 1) 
                      if( k3==Timing_index_2 | k3==Timing_index_3)                      	                      
	                      % 小频偏估计
	                      if(t == 1 )                              
	                          PP_temp = PP( Timing_index_1 );
                              
                              % 估计出小频偏在相关长度内累计的相位的值
	                          phase_offset_1 = angle(PP_temp);
                                                                 
                                  % 调试和测试中需要观察的标量
                                  Timing_index_1
                                  Timing_index_2
                                  phase_offset_1
                                  phase_offset_1_for_1 = phase_offset_1/pi                              
                                  
	                          % 补偿第一个长训练字的小数倍频偏                             
                              index_temp = Timing_index_2;
                              for ii=1:1:2*Nfft
                                  if(index_temp-2*Nfft+ii<=0)
                                      temp_ii = index_temp-2*Nfft+ii+Ntotal*2*2;
                                  else
                                      temp_ii = index_temp-2*Nfft+ii;
                                  end                                  
                                  train_1_received(ii) = c_2(temp_ii);
                              end
                                                                          
                              index_temp = Timining_theory + Ntotal*2*(t-1);
	                          for temp_i=1:2*Nfft
	                              train_1_correct(temp_i) = train_1_received(temp_i)*exp(-1*j*2*(index_temp-2*Nfft-2*Ng+2*Ng+temp_i)*phase_offset_1/(2*Nfft));
	                          end  
                              
                              t = 2;
                          end
                                                    
                          % 大频偏估计和信道响应的估计
	                      if (t==2) 
                              % 补偿第二个长训练字的小数倍频偏  
                              index_temp = Timing_index_3;                             
                              for ii=1:1:2*Nfft
                                  if(index_temp-2*Nfft+ii<=0)
                                      temp_ii = index_temp-2*Nfft+ii+Ntotal*2*2;
                                  else
                                      temp_ii = index_temp-2*Nfft+ii;
                                  end
                                  
                                  train_2_received(ii) = c_2(temp_ii);
                              end                             

                              index_temp = Timining_theory + Ntotal*2*(t-1);                              	
	                          for temp_i=1:2*Nfft
	                              train_2_correct(temp_i) = train_2_received(temp_i)*exp(-1*j*2*(index_temp-2*Nfft-2*Ng+2*Ng+temp_i)*phase_offset_1/(2*Nfft));
	                          end
	                          
                              % 分别得到两个长训练字的频域信息
	                          train_1_fft(1:2*Nfft)=fft(train_1_correct(1:2*Nfft),2*Nfft);
	                          train_2_fft(1:2*Nfft)=fft(train_2_correct(1:2*Nfft),2*Nfft);
	                          
	                          % 估计整数倍频偏
                              % 具体算法参考Schmidl和Cox的文章
                              % "Robust Frequency and Timing Synchronization for OFDM"
	                          gg_N=8;
	                          for gg=-1*gg_N:1:gg_N
	                              temp_i=gg+gg_N+1;
	                              BB(temp_i)=0;
	                              temp_fra=0;
	                              temp_den=0;
	                              for (temp_k=gg_N*2+1:2:Nfft/2-gg_N*2-1)
	                                  temp_fra=temp_fra + (train_1_fft(temp_k+2*gg))'*(vv(temp_k))'*train_2_fft(temp_k+2*gg);
	                                  temp_den=temp_den + abs(train_2_fft(temp_k))*abs(train_2_fft(temp_k));
	                              end
	                              BB(temp_i)=abs(temp_fra)*abs(temp_fra)/(2*temp_den*temp_den);
	                              
	                              temp_fra=0;
	                              temp_den=0;
	                          end
	                          
	                          [max_value,max_no]=max(BB);
	                          

                              % 估计出整数倍频偏的值
	                          phase_offset_2_temp = (max_no-gg_N-1)*2;
	                          phase_offset_2 = 1*phase_offset_2_temp;
                              
                                  % 调试和测试中需要观察的标量
                                  phase_offset_2
                                  phase_offset_for_1_compare = phase_offset_1/pi + phase_offset_2 - error_f_test*(2*(Nfft)*2)                                  
                              
	                          % 信道响应估计                              
                              index_temp = Timining_theory + Ntotal*2*(t-1);
	                          
	                          for temp_i=1:2*Nfft
	                              train_2_correct_full(temp_i) = train_2_received(temp_i)*exp(-1*j*2*pi*(index_temp-2*Nfft-2*Ng+2*Ng+temp_i)*(phase_offset_1/(pi*2*Nfft)+phase_offset_2/(2*Nfft)));
	                          end 
	                          
	                          train_2_correct_full_fft_temp(1:2*Nfft)=fft(train_2_correct_full(1:2*Nfft),2*Nfft);
	                                                        
                              % 加入模拟子载波的信道响应
	                          for(temp_i = 1:2*Nfft)
	                              train_2_correct_full_fft(temp_i)=train_2_correct_full_fft_temp(temp_i)*exp(j*phase_channel_test(temp_i))*(Ap_channel_test(temp_i));
	                          end	                          
	                          
                              % 相位响应估计
                              % 中间插入0的虚拟子载波位置不进行估计
	                          channel_current_train_2(1:2*Nfft)=0;
	                          
	                          for temp_i=1:2*Nfft
	                              if(temp_i<Nfft/2+1 | temp_i>Nfft+Nfft/2)
	                                  channel_current_train_2(temp_i)=train_2_correct_full_fft(temp_i)/train_word_2(temp_i);
	                              end
	                          end
	                          	                          	                          
	                          phase_channel_current(t,1:2*Nfft) = angle(channel_current_train_2(1:2*Nfft));
	                          phase_channel(t+1,1:2*Nfft) = phase_channel_current(t,1:2*Nfft);
	                          
                              
                              % 幅度响应估计
                              % 中间插入0的虚拟子载波位置不进行估计
	                          for temp_i=1:2*Nfft
	                              if(temp_i<Nfft/2+1 | temp_i>Nfft+Nfft/2)
	                                  Ap_channel_current(t,temp_i) = abs(channel_current_train_2(temp_i));
	                              end
	                          end                              
	                          Ap_channel_current(t,Nfft/2+1:Nfft+Nfft/2) = (1/2)*(Ap_channel_current(t,Nfft/2)+Ap_channel_current(t,Nfft+Nfft/2+1));	
                              
	                          Ap_channel(t+1,1:2*Nfft) = Ap_channel_current(t,1:2*Nfft);	                          
	                          
	                      end  % end of if(t == 2)
	
	                      
                          
                          % 解调出QAM符号
	                      if(t > 2)  
                              % 确定FFT窗口位置
                              if(rem(t,2)==1)
                                  index=Timing_index_2;
                              else
                                  index=Timing_index_3;
                              end                      
	                          %FFTin_temp(1:2*Nfft)=IInter_2(index-2*Nfft-sita_tracking(t)+1:index-sita_tracking(t))+j*QInter_2(index-2*Nfft-sita_tracking(t)+1:index-sita_tracking(t));      
                              for ii=1:1:2*Nfft
                                  if(index-2*Nfft+ii-sita_tracking(t)<=0)
                                      temp_ii = index-2*Nfft+ii-sita_tracking(t)+Ntotal*2*2;
                                  else
                                      temp_ii = index-2*Nfft+ii-sita_tracking(t);
                                  end
                                  
                                  FFTin_temp(ii) = c_2(temp_ii);
                              end  
                              
                              % 对接收数据进行载波频偏补偿
                              index_temp = Timining_theory + Ntotal*2*(t-1);                              
	                          for temp_i=1:2*Nfft
	                              FFTin(temp_i) = FFTin_temp(temp_i)*exp(-1*j*2*pi*(index_temp-2*Nfft-2*Ng+2*Ng+temp_i)*(phase_offset_1/(pi*2*Nfft)+phase_offset_2/(2*Nfft)));
	                          end
	                          
	                          FFTout_temp(t,1:2*Nfft)=fft(FFTin,2*Nfft);
	                          
                              
                              % 加入模拟子载波的信道响应
	                          for(temp_i=1:2*Nfft)
	                              FFTout_ch_dis(t,temp_i) = FFTout_temp(t,temp_i)*exp(1*j*phase_channel_test(temp_i))*(Ap_channel_test(temp_i)); 
	                          end
	                        
                              % 解调出每个子载波上的数据
	                          for(temp_i=1:2*Nfft)
	                              FFTout(t,temp_i)=FFTout_ch_dis(t,temp_i)*exp(-1*j*phase_channel(t,temp_i))*(1/Ap_channel(t,temp_i));
	                          end
                                                            
                              
                              % 解出QAM符号,测试误符号率
                              for(temp_i=1:2*Nfft)
                                  
                                  if(temp_i<Nfft/2+1 | temp_i>Nfft+Nfft/2)
                                      
                                      if( rem(temp_i,(Nfft/M_pilot)) ~= 0 )
                                          
                                            I_re(temp_i)=real(FFTout(t,temp_i));
                                            Q_re(temp_i)=imag(FFTout(t,temp_i));
                                            
                                            
                              
                                            if (I_re(temp_i)< -2) 
                                                I_demod(temp_i) = -3;

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -