m认知无线电网络中频谱感知的按需路由算法matlab仿真

1.算法概述

 使用无线电用户的频率范围在 9kHz 到 275GHz[3]，由于无线通信环境中的干扰、信道衰落和无线电收发设备自身属性等的影响，大部分无线电设备只能工作在 50GHz 以下。在 3GHz 以上无线频谱资源利用率较低，3GHz 以下的利用率低于30%[4]。因此，频谱资源缺乏的主要原因为不合理的频谱资源管理政策。

  在低频段的频谱利用率较高，但在中频段和高频段利用率极低，固定的频谱管理政策是导致无线频谱资源短缺的真正原因，不是频谱资源不能满足用户需求。

   认知无线电让无线通信设备能够主动寻找可用信道，将未被使用的频谱资源进行再次利用，具体可通过认知无线电的智能化特性实现频率、时间和空间域不同频谱环境的信号感知，来充分满足用户使用需求。认知无线电本身存在学习能力，能够对通信环境中的变化做出分析和判断，然后能寻找到“频谱空穴”。

   当一个节点需要给网络中的其他节点传送信息时，如果没有到达目标节点的路由，则必须先以多播的形式发出RREQ(路由请求)报文。RREQ报文中记录着发起节点和目标节点的网络层地址，邻近节点收到RREQ，首先判断目标节点是否为自己。如果是，则向发起节点发送RREP(路由回应);如果不是，则首先在路由表中查找是否有到达目标节点的路由，如果有，则向源节点单播RREP，否则继续转发RREQ进行查找。
   按需路由选择（ODR）。ODR使用Cisco发现协议（CDP）来在分支（末节）路由器和中央路由器之间传输网络信息。与动态路由选择协议相比，ODR提供IP路由选择信息的开销非常小；而与静态路由相比，ODR的手工配置量更少。

   在大规模的路由网络中，例如在一个由省-地市-县-营业点组成的四级远程互连的路由网络中，如何维护大量的营业点路由器的直连子网路由和配置营业点的静态路由成为一个巨大的负担.此案例中说明了如何利用cisco On-Demand Routing (ODR)技术来优化这种大规模路由网络的一个设想.

算法A文献：

算法B：

  基础算法B是基础算法A的简化，路径的退避时延只是节点退避时延的累加。算法的具体解释，参考文献’基础算法B’。

2.仿真效果预览 matlab2013b仿真

3.MATLAB部分代码预览

for i = 1:NUM_SOP
    SOP_fre(i)  = 10*round(MAX_Fre/10*rand(1,1)) + MIN_Fre;%设置总共的频段情况20M~2400M,频段变换步进为10M
end
k        = 0.01;%调整10M的频率段，需要时间10ms。
Infor    = cell(sqrt(Num_node),sqrt(Num_node));
NUM_SOUR = 1;%源节点个数
NUM_DENT = 1;%目标节点个数
 
if sel_sna == 1
Band_W   = 2;%带宽统一为2M
end
 
if sel_sna == 2
   Band_Ws  = cell(sqrt(Num_node),sqrt(Num_node));%定义每个节点的带宽
   SNRi     = cell(sqrt(Num_node),sqrt(Num_node));%定义每个节点之间的信噪比
   Pi       = cell(sqrt(Num_node),sqrt(Num_node));%定义每个节点之间数据传输的不成果概率
end
 
 
S_data   = 0.3;%定义每个数据包的大小，通常，这个数据包的大小是相同的。
P0       = 0.7;%表示节点P观察到某个频段可用同时Q也观察到这个频段可用的概率；
qc       = 0.8;%在Q没有观察到频段可用而P观察到频段可用的概率
Pc       = 0.1;%每个节点的冲突概率
W0       = cell(sqrt(Num_node),sqrt(Num_node));%表示IEEE 802.11指数退避流程中退避窗口的最小值
 
 
Stime    = 100;%利用蒙特卡罗的仿真思想，对结果进行多次仿真，求平均
 
 
for pp = 1:Stime
    pp
%%
%-----START：初始化产生节点，注意，这里，节点的显示用方格坐标显示，但是实际的位置信息均存储在每个节点的信息cell中
%-----START：初始化产生节点，注意，这里，节点的显示用方格坐标显示，但是实际的位置信息均存储在每个节点的信息cell中
%-----START：初始化产生节点，注意，这里，节点的显示用方格坐标显示，但是实际的位置信息均存储在每个节点的信息cell中
%-----START：初始化产生节点，注意，这里，节点的显示用方格坐标显示，但是实际的位置信息均存储在每个节点的信息cell中
%以下的代码仅仅为显示节点
[X_view,Y_view,Index] = func_postion(Num_node);
% figure(1);
% for i = 1:sqrt(Num_node)
%     for j = 1:sqrt(Num_node)
%         plot(X_view(i,j),Y_view(i,j),'b.');hold on
%     end
% end
 
%下面的是产生的每个节点的基本信息
%以下的信息是基于AOVD协议产生每个节点的基本信息
%产生坐标信息
POS = cell(sqrt(Num_node),sqrt(Num_node));
X   = zeros(sqrt(Num_node),sqrt(Num_node));
Y   = zeros(sqrt(Num_node),sqrt(Num_node));
for i = 1:sqrt(Num_node)
    for j = 1:sqrt(Num_node)
        X(i,j)   = RR*rand(1,1);Y(i,j) = RR*rand(1,1);
        POS{i,j} = [X(i,j),Y(i,j)];
    end
end
 
%产生每个节点的附近的所有的频段,每个节点附近的频段的个数是随机的1~NUM_SOP
FRE = cell(sqrt(Num_node),sqrt(Num_node));
for i = 1:sqrt(Num_node)
    for j = 1:sqrt(Num_node)
        tmp     = randint(1,1,[1,NUM_SOP/2]);          %产生该节点的频段数的个数
        Ind_sop = unique(randint(1,tmp,[1,NUM_SOP]));%产生对应个数的随机频段的编号
        FRE{i,j}= unique(SOP_fre(Ind_sop));                  %每个节点附近的随机频点，构成SOP集合来模拟频谱分布的非均匀性
    end
end
 
%产生每个节点的数据流
%分别定义单数据流；
%-------多数据流：并行的数据流，交叉的数据流以及随机的数据流；
[Data_flow,Starts,Ends] = func_data_flow(Num_node,sel_type);
 
%产生每个节点的退避最大窗口
for i = 1:sqrt(Num_node)
    for j = 1:sqrt(Num_node)
        W0{i,j} = 8-0.5*length(FRE{i,j}); 
    end
end
 
%定义每个节点的带宽
for i = 1:sqrt(Num_node)
    for j = 1:sqrt(Num_node)
        Band_Ws{i,j} = 2 + (1-2*rand(1,1));%通常情况下节点的带宽都是相同的 
    end
end
 
%定义每个节点之间的信噪比
for i = 1:sqrt(Num_node)
    for j = 1:sqrt(Num_node)
        SNRi{i,j} = 5 + 2*rand(1,1);%每个路径的SNR包括固有的5db以及随机性差异
    end
end
 
%定义每个节点之间数据传输的不成概率
for i = 1:sqrt(Num_node)
    for j = 1:sqrt(Num_node)
        Pi{i,j} = 0.5 + 0.5*rand(1,1);%满足高斯分布
    end
end
 
 
 
%-----OVER：节点的初始化信息结束，通过循环可知，每次的参数是时变的，符合实际情况
%-----OVER：节点的初始化信息结束，通过循环可知，每次的参数是时变的，符合实际情况
%-----OVER：节点的初始化信息结束，通过循环可知，每次的参数是时变的，符合实际情况
%-----OVER：节点的初始化信息结束，通过循环可知，每次的参数是时变的，符合实际情况
 
%%
%%
%%
%%
 
%%
%-----START：通过基础算法A的相关方法计算目标路径的延迟
%-----START：通过基础算法A的相关方法计算目标路径的延迟
%-----START：通过基础算法A的相关方法计算目标路径的延迟
%-----START：通过基础算法A的相关方法计算目标路径的延迟
%根据之前定义的数据流，找到数据流的源节点和目标节点，并根据最小延迟算法确定实际的路径
%[Data_flow,Starts,Ends]   
%根据已知的路径和SOP集合，计算每个交叉节点的冲突数
 
%通过计算延迟，使每个节点的频谱进行重新分配，从而使延迟达到最小值，频谱从初始化产生的SOP集合中选择
%计算初始的冲突数量，后面在动态分配频段的时候，进行实时的更新
Num   = zeros(sqrt(Num_node),sqrt(Num_node));
Num = func_find_Num(Data_flow,FRE,Num_node);
 
for i = 1:length(Starts)
    for j = 1:length(Data_flow{i})
        
 
        %首先计算节点延迟
        %首先计算节点延迟
        %不是目标节点,是中间节点
        %不是目标节点,是中间节点
        %不是目标节点,是中间节点
        if j < length(Data_flow{i})
                tmp1 = Data_flow{i}(:,j);
                tmp2 = Data_flow{i}(:,j+1); 
            %首先判断当前节点下有误存在交集，如果没有频段的交集则丢去该帧
            if  FRE{tmp1(1),tmp1(2)}(1) == FRE{tmp2(1),tmp2(2)}(1)
                Dswitching(j) = 0;
                if Num(tmp1(1),tmp1(2)) > 0
                   Dbackoff(j)   = W0{tmp1(1),tmp1(2)}/((1-Pc) * (1-(1-Pc)^(1/(Num(tmp1(1),tmp1(2))-1))));
                else
                   Dbackoff(j)   = 0;
                end                
            else
                Dswitching(j) = 2*k*abs(FRE{tmp1(1),tmp1(2)}(1) - FRE{tmp2(1),tmp2(2)}(1));
                if Num(tmp1(1),tmp1(2)) > 0
                   Dbackoff(j)   = W0{tmp1(1),tmp1(2)}/((1-Pc) * (1-(1-Pc)^(1/(Num(tmp1(1),tmp1(2))-1))));
                else
                   Dbackoff(j)   = 0;
                end
            end
            
            %计算传输延迟
            Dtrans(j)       = (1/(1-Pi{tmp1(1),tmp1(2)}))*S_data/( Band_Ws{tmp1(1),tmp1(2)}*log2(1 + SNRi{tmp1(1),tmp1(2)}) );
            %进行延迟信息反馈RREQ反馈
            DN(j)          = Dswitching(j) + Dbackoff(j) + Dtrans(j) ; 
  
            
        else%如果是目标节点
            %如果是目标节点
            %如果是目标节点
            tmp1 = Data_flow{i}(:,j);
            tmp2 = Data_flow{i}(:,j);         
            
            indss1 = 1;
            
            %搜索最小DN值
            for hh1 = 1:length(FRE{tmp1(1),tmp1(2)})
                for hh2 = 1:length(FRE{tmp2(1),tmp2(2)}) 
                    indss1 = indss1 + 1;
                    %更新频段
                    Fre_now  = FRE{tmp1(1),tmp1(2)}(hh1);
                    %更新冲突数
                    Fre_nows                  = FRE;
                    Fre_nows{tmp1(1),tmp1(2)} = Fre_now;
                    Num = func_find_Num(Data_flow,FRE,Num_node);
 
                    Dswitching(indss1) = 2*k*abs(FRE{tmp1(1),tmp1(2)}(hh1) - FRE{tmp2(1),tmp2(2)}(hh2));
                    if Num(tmp1(1),tmp1(2)) > 0
                       Dbackoff(indss1)   = W0{tmp1(1),tmp1(2)}/((1-Pc) * (1-(1-Pc)^(1/(Num(tmp1(1),tmp1(2))-1))));
                    else
                       Dbackoff(indss1)   = 0;
                    end
                    
                    %计算传输延迟
                    Dtrans(indss1)       = (1/(1-Pi{tmp1(1),tmp1(2)}))*S_data/( Band_Ws{tmp1(1),tmp1(2)}*log2(1 + SNRi{tmp1(1),tmp1(2)}) );
                    %进行延迟信息反馈RREQ反馈
                    DNss(indss1)         = Dswitching(indss1) + Dbackoff(indss1) + Dtrans(indss1) ; 
                end
            end
            %找到最小值，给出最小值对应的频段及相关参数
            DN(j) = min(DNss);
        end
        Num = func_find_Num(Data_flow,FRE,Num_node);
        %计算路径延迟    
        %计算路径延迟  
        indss = 0;
        for pp1 = 1:length(FRE{tmp1(1),tmp1(2)})
            for pp2 = 1:length(FRE{tmp2(1),tmp2(2)})
                indss = indss + 1;
                H = length(Data_flow{i})-j+1;%多跳跳数
 
                for j2 = 1:H
                    Dswitchingi_tmp(j2) = k*abs(FRE{tmp1(1),tmp1(2)}(pp1) - FRE{tmp2(1),tmp2(2)}(pp2));
                end
                Dswitchingi(indss) = sum(Dswitchingi_tmp);
                if mod(H,2) == 0%偶数
                   for j2 = 1:H
                       Uhx_tmp(j2) = (1-P0)*qc^((1-Pc^j2)/(1-Pc^2)); 
                   end
                   Uhx = sum(Uhx_tmp);
                end
                if mod(H,2) == 1%奇数
                   for j2 = 1:H
                       Uhx_tmp(j2) = (1-P0)*qc^((1-Pc^j2)/(1-Pc^2)) + P0*Pc^(j2-1); 
                   end
                   Uhx = sum(Uhx_tmp);        
                end       
                Dbackoffi(indss)   = (S_data/Band_Ws{tmp1(1),tmp1(2)}) * (floor((H+1)/2) - Uhx)/Uhx;
                DPss(indss)          = Dswitchingi(indss) + Dbackoffi(indss);
            end
        end
        DP(j) = min(DPss);
        
        Droutej(j)     = DP(j) + DN(j);
 
    end
 
    Droutej_i(:,i)     = Droutej;
    
 
    
end
    F_Droutej_i(:,:,pp) = Droutej_i;
end
%-----OVER：通过基础算法A的相关方法计算目标路径的延迟
%-----OVER：通过基础算法A的相关方法计算目标路径的延迟
%-----OVER：通过基础算法A的相关方法计算目标路径的延迟
%-----OVER：通过基础算法A的相关方法计算目标路径的延迟
 
 
%最后的延迟为F_Droutej_i进行求平均
for i = 1:size(Droutej_i,1)
    for j = 1:size(Droutej_i,2)
        Droutej_i_average(i,j) = mean(F_Droutej_i(i,j,:));
    end
end
Droutess = mean(mean(Droutej_i_average));
01_044_m