这篇日子是参考《通信收发机的Verilog实现与仿真》第五章 Verilog在扩频通信中的应用。

网路上有关PN码产生以及捕获资料很多，但是介于本人对其原理的模糊，实在不知道设计时每一步的具体操作如何。所以花点时间学习一下，放在这里，以防忘记。如果以后做移动通信，或许用的到。就这个东西，前前后后断断续续看了一个星期，花了时间，也算学习了东西。

譬如《通信收发信机的verilog实现与仿真》中就有PN码的捕获方案，该方案简单介绍了PN码的产生和捕获原理。产生就是普通的M序列的方法，而捕获用的是滑动相关法。为了加快捕获的速度，设计中使用了10路相关信号，如果而10路相关信号每一路都占用单独的逻辑，那么整个系统的逻辑占有量将成倍增长，原因是在滑动相关捕获方案中首先需要相加，然后相乘。eg，一路捕获，输入是8bit，那么加法器就是两输入的8bit，乘法器就是两输入的16bit。十路捕获，资源占有量，不可容忍，共20个8比特两输入加法器，20个16比特两输入乘法器。为了解决这个问题，本书以及众多解决方案给出的方法是共享逻辑（书中说的是流水线），用三路加法器，二路乘法器来实现相关计算以及最后的检测。因为接收到的信号包含同相信号和正交信号，所以实际上一共是6个加法器，四个乘法器。大大减少了资源。十路PN信号使用十个pn_generator例化实现，共享逻辑的核心和按照设计了一个计数器sys_counter，不同的时间对来自不同路的信号做对应的操作。我整理了一下，用verilogHDL语言的形式与自然语言联合表示如下，不求语法正确，只求理解具体操作。

case（sys_counter）

4‘b0000：3、4、5路输入的信号输入到加法器输入端，加法器进行0、1、2路相关运算；

4’b0001：6、7、8路输入的信号输入到加法器，加法器进行3、4、5路相关运算，0、1、2路的相关结果输入到对应的相关结果寄存器；

4‘b0010：9路输入的信号输入到加法器，加法器进行6、7、8路相关运算，3、4、5路的相关结果输入到对应的相关结果寄存器，0、1路相关结果输入到乘法器输入端；

4’b0011：加法器进行9路信号相关、6、7、8路的相关结果输入到对应的相关结果寄存器，0、1路同相、正交信号功率存储；2、3路相关结果输入到乘法器输入端；

4‘b0100：9路的相关结果输入到对应的相关结果寄存器，4、5路相关结果到乘法器输入端，2、3路同相、正交信号功率存储；0、1路正交、同相相加存储；

4’b0101：6、7路相关结果到乘法器输入端，4、5路同相、正交信号功率存储，2、4路正交、同相相加存储，比较0路功率与阈值的大小，得到capture；

4‘b0110：8、9路相关结果输入到乘法器，6、7路同相、正交信号功率存储，4、5路正交、同相相加存储，比较1路功率与阈值的大小，得到capture；

4’b0111：8、9路同相、正交信号功率存储，6、7路正交、同相相加存储，比较2路功率与阈值的大小，得到capture；

4‘b1000：8、9路正交、同相相加存储，比较3路功率与阈值的大小，得到capture；

4’b1001：比较4路功率与阈值的大小，得到capture；

4‘b1010：比较5路功率与阈值的大小，得到capture；

4’b1011：比较6路功率与阈值的大小，得到capture；

4‘b1100：比较7路功率与阈值的大小，得到capture；

4’b1101：比较8路功率与阈值的大小，得到capture；

4‘b1110：比较9路功率与阈值的大小，得到capture；

4’b1111：0、1、2路输入的信号输入到加法器；

endcase

到4‘b1111，完成一个周期，因为每16个clk只需要度每一路完成一次操作，所以共享逻辑可以完成这样的功能，而且分几次寄存了计算的结果。数据的输入速度是clk的1/16。

信号处理过程中分几次寄存数据，输入数据寄存，加法结果寄存（这个是必要的，也就是相关处理的结果寄存），乘法输入寄存（需要提前将进行乘法的数据从相关结果寄存器中读出）、乘法结果寄存、功率结果寄存。

计算步骤：输入信号和加法器上次结果输入到加法器根据PN值相加进行相关操作、求同相正交信号的平方、求一路信号的功率（也就是同相信号平方+正交信号平方）、阈值比较等到捕获同步的结果。这写代码可以见参考书，有一次证明，看代码是件痛苦的事情，这些代码还有很多注释。另外：可能作者最初写代码的时候是整个系统用一个module实现的，而为了排版书籍的缘故将原来的程序划分为几个块，也为了更好的注释，但是划分块以后没有对一些信号进行更好的处理，譬如一些信号在一个块中没有定义却拿来使用，而sys_counter在serial_xiangguan模块中只是定义，没有具体实现，读者只有参考了后面的模块才能知道。还有许多，不一一提及。而这个计数器为什么定义那么多位，而且为什么那样定义，我还不清楚，等做完后续实验再说一下。而且为了节省资源，对resi_*和resq_*进行了共享，先放置相关结果，等相关数据使用完毕后，再放置相关后平方的结果。等等，这些内容在程序中并没有交代清楚。

对于上面的实例无法透彻理解的前提下，就觉得做一路捕获试试，或许能够理解基本原理与操作。不考虑系统的效率问题，单路信号，时钟clk2设置为输入数据的4倍就可以，基本操作还是相加实现相关、相乘实现同相或正交功率计算、相加得到信号功率、与阈值比较的到capture结果。pn_generator没有变化。实现捕获的程序如下。

module pn_capture(clk, clr, en, data_i, data_q, a, capture);
    input clk;//4倍于 data的时钟
    input clr;//清除
    input en;//使能
    input [7:0] data_i;//同相信号
    input [7:0] data_q;//正交信号
    output reg capture;//捕获信号
  
  input [6:0] a;//PN码生成器初始值
  reg [1:0] count;//2bit计数器，控制计算过程
  parameter idle=2'b00,co_add=2'b01,mul=2'b10,power_add=2'b11;

//对应不同的计算状态
  parameter criterion=37'h07_ffff_ffff;//峰值阈值
  reg signed [14:0] resi_add;//同相相加结果，也就是相关
  reg signed [14:0] resq_add;//正交相加结果，也就是相关
  reg signed [35:0] mul_result_i;//同相相关后平方
  reg signed [35:0] mul_result_q;//正交相关后平方
  reg [36:0] res;//功率寄存
  wire pn;//PN码

//生成PN码  
pn_generator pn0(.a(a), .clk(clk), .clr(clr), .en(en), .pn(pn));

//控制计算的计数器

always @(posedge clk)
begin
    if(clr)    count<=0;
    else    if(en)    
      begin
        if(count==2'b11)    count<=0;
        else    count<=count+1'b1;
    end
    else    count<=0;
end

//

always @(posedge clk)
begin
    if(clr)    
      begin 
        resi_add<=0;resq_add<=0;
        mul_result_i<=0;mul_result_q<=0;
        res<=0;
    end
  else    if(en)
        case(count)
       idle:    begin 
                      resi_add<=resi_add;resq_add<=resq_add;//
                 end
       co_add:  begin//相关
                 if(pn)

begin resi_add<=resi_add-data_i;

resq_add<=resq_add-data_q;end
                 else    begin resi_add<=resi_add+data_i;

resq_add<=resq_add+data_q;end
             end
         mul:     begin //相乘
                    mul_result_i[35:0]<=resi_add*resi_add;
                    mul_result_q[35:0]<=resq_add*resq_add;
                     end
    power_add:    begin res[36:0]<=mul_result_i+mul_result_q;end//功率
    endcase
end

//捕获判断

always @(posedge clk)
begin
    if(clr)    capture<=0;
  else    if(en)
      begin
        if(res>criterion)    capture<=1;
        else    capture<=0;
    end
        else    capture<=0;
end
endmodule

按照作者的意图，按照我的理解，将作者原来的程序修正如下。感受啊！作者不认真，真的要人命，作者一偷懒，读者费死劲，作者一疏忽，读者真是服。

module pn_serial_corelated(clk, clr, data_i, data_q, pn);
    input clk;
    input clr;
    input [7:0] data_i;
    input [7:0] data_q;
    output reg pn;
    reg pn_1;
  reg pn_2;
  reg en;
    reg [6:0] a,a0,a1,a2,a3,a4,a5;
  wire [9:0]pn_10;
  reg signed [7:0] reg_i,reg_q;
  reg signed [14:0] resi_add_0,resi_add_1,resi_add_2;
  reg signed [14:0] resq_add_0,resq_add_1,resq_add_2;
  reg signed [14:0] resi_in_0,resi_in_1,resi_in_2;
  reg signed [14:0] resq_in_0,resq_in_1,resq_in_2;
  reg signed [35:0] resi_0,resi_1,resi_2,resi_3,resi_4;
  reg signed [35:0] resi_5,resi_6,resi_7,resi_8,resi_9;
  reg signed [35:0] resq_0,resq_1,resq_2,resq_3,resq_4;
  reg signed [35:0] resq_5,resq_6,resq_7,resq_8,resq_9;
  reg signed [36:0] res_0,res_1,res_2,res_3,res_4,res_5;
  reg signed [36:0] res_6,res_7,res_8,res_9;
  reg [3:0] waitnum;
  reg [16:0] sys_counter;
  reg [3:0] pn_max_num;
  reg [36:0] criterion;
  reg capture;
  reg signed [36:0] max;
  wire signed [35:0] mul_result_i_0;
  wire signed [35:0] mul_result_q_0;
  wire signed [35:0] mul_result_i_1;
  wire signed [35:0] mul_result_q_1;  
  reg signed [14:0] mul_i_0;
  reg signed [14:0] mul_q_0;
  reg signed [14:0] mul_i_1;
  reg signed [14:0] mul_q_1;
  
  wire en_pn; 
  
  
pn_generator mypn0(.a(a0),.clk(clk),.pn(pn_10[0]),.en(en_pn),.clr(clr));
pn_generator mypn1(.a(a1),.clk(clk),.pn(pn_10[1]),.en(en_pn),.clr(clr));
pn_generator mypn2(.a(a2),.clk(clk),.pn(pn_10[2]),.en(en_pn),.clr(clr));
pn_generator mypn3(.a(a3),.clk(clk),.pn(pn_10[3]),.en(en_pn),.clr(clr));
pn_generator mypn4(.a(a4),.clk(clk),.pn(pn_10[4]),.en(en_pn),.clr(clr));
pn_generator mypn5(.a(a5),.clk(clk),.pn(pn_10[5]),.en(en_pn),.clr(clr));
pn_generator mypn6(.a(a),.clk(clk),.pn(pn_10[6]),.en(en_pn),.clr(clr));
pn_generator mypn7(.a(a),.clk(clk),.pn(pn_10[7]),.en(en_pn),.clr(clr));
pn_generator mypn8(.a(a),.clk(clk),.pn(pn_10[8]),.en(en_pn),.clr(clr));
pn_generator mypn9(.a(a),.clk(clk),.pn(pn_10[9]),.en(en_pn),.clr(clr));

//按照面积优化，会将mypn7/mypn8/mypn9优化。

//wire en_pn;
assign en_pn=((sys_counter==4'b0011)&&en);
always @(posedge clk)
begin
    if(clr)
      begin
        a<=7'b100_0000;a0<=7'b000_1000;
    a1<=7'b000_0001;a2<=7'b100_0001;
    a3<=7'b100_0100;a4<=7'b100_1001;
    a5<=7'b100_1100;
    reg_i<=0;reg_q<=0;   
    end
    else    if(en)
      begin
        if(sys_counter[3:0]==4'b1111)
        begin
          reg_i<=data_i; reg_q<=data_q;
      end
    end
end

always @(posedge clk)
begin
     if(clr)
       begin
      resi_add_0<=0;resi_add_1<=0;resi_add_2<=0;
    resq_add_0<=0;resq_add_1<=0;resq_add_2<=0;
    resi_in_0<=0;resi_in_1<=0;resi_in_2<=0;
    resq_in_0<=0;resq_in_1<=0;resq_in_2<=0;
    resi_0<=0;resi_1<=0;resi_2<=0;resi_3<=0;resi_4<=0;
    resi_5<=0;resi_6<=0;resi_7<=0;resi_8<=0;resi_9<=0;
    resq_0<=0;resq_1<=0;resq_2<=0;resq_3<=0;resq_4<=0;
    resq_5<=0;resq_6<=0;resq_7<=0;resq_8<=0;resq_9<=0;
    res_0<=0;res_1<=0;res_2<=0;res_3<=0;res_4<=0;
    res_5<=0;res_6<=0;res_7<=0;res_8<=0;res_9<=0;
   end
    else    if(en)
      begin
      case(pn)
    1'b0:
        begin
        resi_add_0<=resi_in_0+reg_i;
      resq_add_0<=resq_in_0+reg_q;
    end
    1'b1:
        begin
        resi_add_0<=resi_in_0-reg_i;
      resq_add_0<=resq_in_0-reg_q;
    end
    endcase
      case(pn_1)
    1'b0:
        begin
        resi_add_1<=resi_in_1+reg_i;
      resq_add_1<=resq_in_1+reg_q;
    end
    1'b1:
        begin
        resi_add_1<=resi_in_1-reg_i;
      resq_add_1<=resq_in_1-reg_q;
    end
    endcase    
    case(pn_2)
    1'b0:
        begin
        resi_add_2<=resi_in_2+reg_i;
      resq_add_2<=resq_in_2+reg_q;
    end
    1'b1:
        begin
        resi_add_2<=resi_in_2-reg_i;
      resq_add_2<=resq_in_2-reg_q;
    end
    endcase
    case(sys_counter[3:0])
    4'b0000:
        begin
        pn<=pn_10[3];
      pn_1<=pn_10[4];
      pn_2<=pn_10[5];
      resi_in_0<=resi_3[14:0];
      resi_in_0<=resq_3[14:0];
      resi_in_1<=resi_4[14:0];
      resq_in_1<=resq_4[14:0];
      resi_in_2<=resi_5[14:0];
      resq_in_2<=resq_5[14:0];
    end
        4'b0001:
        begin
        pn<=pn_10[6];
      pn_1<=pn_10[7];
      pn_2<=pn_10[8];
      resi_0[14:0]<=resi_add_0;
      resi_1[14:0]<=resi_add_1;
      resi_2[14:0]<=resi_add_2;
      resi_in_0<=resi_6[14:0];
      resi_in_1<=resi_7[14:0];
      resi_in_2<=resi_8[14:0];
      resq_0[14:0]<=resq_add_0;
      resq_1[14:0]<=resq_add_1;
      resq_2[14:0]<=resq_add_2;
      resq_in_0<=resq_6[14:0];
      resq_in_1<=resq_7[14:0];
      resq_in_2<=resq_8[14:0];
    end
    4'b0010:
        begin
        pn<=pn_10[9];
      resi_3[14:0]<=resi_add_0;
      resi_4[14:0]<=resi_add_1;
      resi_5[14:0]<=resi_add_2;
      resi_in_0<=resi_9[14:0];
      resq_3[14:0]<=resq_add_0;
      resq_4[14:0]<=resq_add_1;
      resq_5[14:0]<=resq_add_2;
      resq_in_0<=resq_9[14:0];
      
      if(sys_counter[10:4]==7'b000_0000)
          begin
            mul_i_0<=resi_0[14:0];
        mul_q_0<=resq_0[14:0];
        mul_i_1<=resi_1[14:0];
        mul_q_1<=resq_1[14:0];
        end
    end
        4'b0011:
        begin
        resi_6[14:0]<=resi_add_0;
      resi_7[14:0]<=resi_add_1;
      resi_8[14:0]<=resi_add_2;
      resq_6[14:0]<=resq_add_0;
      resq_7[14:0]<=resq_add_1;
      resq_8[14:0]<=resq_add_2;
      if(sys_counter[10:4]==7'b000_0000)
          begin
            mul_i_0<=resi_2[14:0];
        mul_q_0<=resq_2[14:0];
        mul_i_1<=resi_3[14:0];
        mul_q_1<=resq_3[14:0];
        resi_0<=mul_result_i_0;
        resq_0<=mul_result_q_0;
        resi_1<=mul_result_i_1;
        resi_1<=mul_result_q_1;
        end
    end
    4'b0100:
        begin
        resi_9[14:0]<=resi_add_0;
      resq_9[14:0]<=resq_add_0;
      if(sys_counter[10:4]==7'b000_0000)
          begin
            mul_i_0<=resi_4[14:0];
        mul_q_0<=resq_4[14:0];
        mul_i_1<=resi_5[14:0];
        mul_q_1<=resq_5[14:0];
        resi_2<=mul_result_i_0;
        resq_2<=mul_result_q_0;
        resi_3<=mul_result_i_1;
        resq_3<=mul_result_q_1;
        res_0<=resi_0+resq_0;
        res_1<=resi_1+resq_1;
        end
      
    end
    4'b0101:
        begin
        if(sys_counter[10:4]==7'b000_0000)
          begin
            mul_i_0<=resi_6[14:0];
        mul_q_0<=resq_6[14:0];
        mul_i_1<=resi_7[14:0];
        mul_q_1<=resq_7[14:0];
        resi_4<=mul_result_i_0;
        resq_4<=mul_result_q_0;
        resi_5<=mul_result_i_1;
        resi_5<=mul_result_q_1;
        res_2<=resi_2+resq_2;
        res_3<=resi_3+resq_3;
        if(res_0>max)
            begin
              pn_max_num<=0;
            max<=res_0;
          end
        end
    end
    4'b0110:
        begin
        if(sys_counter[10:4]==7'b000_0000)
          begin
           mul_i_0<=resi_8[14:0];
         mul_q_0<=resq_8[14:0];
         mul_i_1<=resi_9[14:0];
         mul_q_1<=resq_9[14:0];
         resi_6<=mul_result_i_0;
         resq_6<=mul_result_q_1;
         resi_7<=mul_result_i_1;
         resi_7<=mul_result_q_1;
         res_4<=resi_4+resq_4;
         res_5<=resi_5+resq_5;
         if(res_1>max)
             begin
             pn_max_num<=1;
           max<=res_1;
         end
        end
    end
    4'b0111:
        begin
        if(sys_counter[10:4]==7'b000_0000)
                    begin
            resi_8<=mul_result_i_0;
        resq_8<=mul_result_q_0;
        resi_9<=mul_result_i_1;
        resq_9<=mul_result_q_1;
        res_6<=resi_6+resq_6;
        res_7<=resi_7+resq_7;
        if(res_2>max)
            begin
              pn_max_num<=2;
            max<=res_2;
          end
                    end        
    end
    4'b1000:
        begin
        if(sys_counter[10:4]==7'b000_0000)
          begin
            res_8<=resi_8+resq_8;
        res_9<=resi_9+resq_9;
        if(res_3>max)
            begin
              pn_max_num<=3;
            max<=res_3;
          end
        end
    end
    4'b1001:
        begin
        if(sys_counter[10:4]==7'b000_0000)
          begin
            if(res_4>max)
            begin
              pn_max_num<=4;
            max<=res_4;
          end
        end
    end
    4'b1010:
        begin
        if(sys_counter[10:4]==7'b000_0000)
          begin
            if(res_5>max)
            begin
              pn_max_num<=5;
            max<=res_5;
          end
        end        
    end
    4'b1011:
        begin
        if(sys_counter[10:4]==7'b000_0000)
          begin
            if(res_6>max)
            begin
              pn_max_num<=6;
            max<=res_6;
          end
        end         
    end
    4'b1100:
        begin
        if(sys_counter[10:4]==7'b000_0000)
          begin
            if(res_7>max)
            begin
              pn_max_num<=7;
            max<=res_7;
          end
        end         
    end
        4'b1101:
        begin
        if(sys_counter[10:4]==7'b000_0000)
          begin
            if(res_8>max)
            begin
              pn_max_num<=8;
            max<=res_8;
          end
        end         
    end 
        4'b1110:
        begin
        if(sys_counter[10:4]==7'b000_0000)
          begin
            if(res_9>max)
            begin
              pn_max_num<=9;
            if(res_9>criterion)    capture<=1;
          end
            else
            begin
              if(max>criterion)    capture<=1;
          end
        end         
    end    
    4'b1111:
        begin
        pn<=pn_10[0];
      pn_1<=pn_10[1];
      pn_2<=pn_10[2];
      resi_in_0<=resi_0[14:0];
      resi_in_1<=resi_1[14:0];
      resi_in_2<=resi_2[14:0];
      resq_in_0<=resq_0[14:0];
      resq_in_1<=resq_1[14:0];
      resq_in_2<=resq_2[14:0];
    end
    default:
        begin
    resi_in_0<=resi_in_0;resi_in_1<=resi_in_1;resi_in_2<=resi_in_2;
    resq_in_0<=resq_in_0;resq_in_1<=resq_in_1;resq_in_2<=resq_in_2;
    resi_0<=resi_0;resi_1<=resi_1;resi_2<=resi_2;resi_3<=resi_3;resi_4<=resi_4;
    resi_5<=resi_5;resi_6<=resi_6;resi_7<=resi_7;resi_8<=resi_8;resi_9<=resi_9;
    resq_0<=resq_0;resq_1<=resq_1;resq_2<=resq_2;resq_3<=resq_3;resq_4<=resq_4;
    resq_5<=resq_5;resq_6<=resq_6;resq_7<=resq_7;resq_8<=resq_8;resq_9<=resq_0;
            end    
    endcase
    end
end

always @(posedge clk)
begin
    if(clr)    begin waitnum<=0;en<=1;end
  else    if(~en)
      begin
        waitnum<=waitnum+1'b1;
    if(waitnum==4'b1111)    en<=1;
    end
    else    if(sys_counter[10:0]==11'b000_0000_1111)
      begin
        if(res_9<criterion&&max<criterion)    en<=0;
    end
end

always @(posedge clk)
begin
    if(clr)    sys_counter<=0;
  else    if(en)
      begin
        if(sys_counter[10:0]==11'b000_0000_1111)

//testbench里面这个地方是

//sys_counter[10:0]==11'b111_1110_1111;
        begin
          sys_counter[10:0]<=0;
        sys_counter[15:11]<=sys_counter[15:11]+1'b1;
      end
    else    sys_counter<=sys_counter+1'b1;
    end
end

always @(posedge clk)
begin
    if(clr)    criterion<=37'h07_ffff_ffff;
end
MULT18X18 mult1(.P(mul_result_i_0),.A(mul_i_0),.B(mul_i_0));
MULT18X18 mult2(.P(mul_result_q_0),.A(mul_q_0),.B(mul_q_0));
MULT18X18 mult3(.P(mul_result_i_1),.A(mul_i_1),.B(mul_i_1));
MULT18X18 mult4(.P(mul_result_q_1),.A(mul_q_1),.B(mul_q_1));
      
endmodule

作者没有对每个模块的测试平台给出注释，而且就其中用到的数据文本也没给出基本的说明，希望再版的时候能注意一下。

下面是PN码的一些知识，摘抄自《CDMA系统的PN码技术》 武汉理工大学信息工程学院　　吴薇

PN：Pseudo-Noise。

PN码序列同步是扩频系统特有的，也是扩频技术 中的难点。CDMA系统要求接收机的本地伪随机码与接收到的PN码在结构、频率和相位上完全一致，否则就不能正常接收所发送的信息，接收到的只是一片噪声。若实现了收发同步但不能保持同步，也无法准确可靠地获取所发送的信息 数数据 。因此，PN码序列的同步是CDMA扩频通信的关键 技术 。

CDMA系统中的PN码同步过程分为PN码捕获（精同步）和PN码跟踪（细同步）两部分。

常用的PN码捕获方法有：

1、滑动相关法
接收系统在搜索同步时，它的码序列发生器以与发射机码序列发生器不同的速率工作，致使这两个码序列在相位上互相滑动，只有在达到一致点时，才停下来，因此称之为滑动相关法。

接收信号与本地PN码相乘后积分，求出它们的互相关值，然后与门限检测器的某一门限值比较，判断是否已捕获到有用信号。它利用了PN码序列的相关徨性，当两个相同的码序列相位一致时，其相关值输出最大。一旦确认捕获完成，捕获指示信号的同步脉冲控制搜索控制钟，调整PN码发生器产生的PN码重复频率和相位，使之与收到的信号保持同步。

　　由于滑动相关器对两个PN码序列按顺序比较相关，所以该方法又称顺序搜索法。滑动相关器简单，应用簋广，缺点是当两个PN码的时间差或相位差过大时，相对滑动速度簋慢，导致搜索时间过长，特别是对长PN码的捕获时间过长，必须采取措施限定捕获范围，加快捕获时间，改善其性能。

　　使滑动相关器实用的有效方法之一是采用特殊码序列，特殊码序列要足够短，以便在合理时间内对所有码位进行搜索。至于短到什么程度，由满足相关性要求限定。这种加前置码的方法称同步引导法。引导码同步要求低、简单易实现，是适合各种应用的同步方法。

　　可捕码由若干较短码序列组合而成，其码序列应与各组成码序列保持一定的相关关系。这类码中最著名的是JPL码。

2、序贯估值法
　序贯估值法是另一种减少长码捕获时间的快速捕获方法，它把收到的PN码序列直接输入本地码发生器的移位寄存器，强制改变各级寄存器的起始状态，使其产生的PN码与外来码相位一致，系统即可立即进行同步跟踪状态，缩短了本地PN码与外来PN码相位一致所需的时间。

　　该方法先检测收到码信号中的PN码，通过开关，送入n级PN码发生器的移位寄存器。待整个码序列全部进入填满后，在相关器中，将产生的PN码与收到的码信号进行相关运算，在比较器中将所得结果与门限进行比较。若未超过门限，则继续上述过程。若超过门限，则停止搜索，系统转入跟踪状态。理想情况下，捕获时间Ts=nTc，（Tc为PN码片时间宽度）。该方法捕获时间虽短，但存在一些问题，它先要对外来的PN码进行检测，才能送入移位寄存器，要做到这一点有时很困难。另外，此法抗干扰能力很差，因为逐一时片进行估值和判决，并未利用PN码的抗干扰特性。但在无干扰条件下，它仍有良好的快速初始同步性能。

3、匹配滤波器法
用于PN同步捕获的匹配滤波器一般采用延时线匹配滤波器，其目的是识别码序列，它能在特殊结构中识别特殊序列，而且只识别该序列。假设一个输入信号是7bit码序列1110010双相调制的信号，每当码有1-0过渡时，反相信号进入延时线，直到第1bit在T7，第2bit在T6。当全部时延元件都填满，而且信号调制码与滤波器时延元件相位一致时，T2的信号相位与T5、T6、T7的相位相同，时延元件T1、T3、T4也具有相同的信号相位。把｛T2、T5、T6、T7｝与｛T1、T3、T4｝两组分别相加，把｛T1、T3、T4｝之和倒相输出，再将这两个结果相加，包含在全部7个元件中的信号能量同相相加，整个输出是未处理的7倍。根据该能量关系可以识别码序列。

　　要增强产生的信号，可以靠附加更多的时延元件实现，在这种结构中得到的处理增益为Gp=10lgn（n是参加求和的时延元件数）。

　　在要求快速锁定及使用长码的CDMA扩频通信中，宜采用SAW-TDL-MF作同步器。对于待定信号，匹配滤波器具有时间 自动 能力，无需PN码时钟同步与RF载波相位锁定，既避免了 数据 信息比特以外的同步，又完成了扩频信号的相关处理。引导码进入程控编码SAW-TDL-MF后，其输出是噪声基底上的底尖相关峰。在扩频通信中，噪声功率控制接收机的AGC，因而信号功率（即相关峰值）在起伏的噪声环境中变化很大。门限计算器的功能根据包络检测输出，确定动态门限电平，提供给同步检测器，保证在低SNR时有可允许的同步误差。动态门限电平取在主峰高度与最大旁峰之间时，噪声引起的底同步误差最小。当SAW-TDL检波输出包络超过动态门限时，同步检测器为接收机宽带频率合成器提供一个逻辑电平同步信号。

××××××××××××××××××××××××××××××××××××××

开始想学习3G，看了一些资料，发现讲协议的太多，根本无法下手，不懂的几乎是整体。然后觉得看移动通信可能好点，果然涉及到具体技术的内容，再仔细才发现扩频通信应该算是现在比较主流的一种技术。

最佳通信系统=最佳发送机+最佳接收机。

一般地，认为：最佳发送就是扩频发送，最佳接受就是相关接受。

　扩频技术是一种信息处理传输技术。扩频技术是利用同域传输数据(信息)无关的码对被传输信号扩展频谱，使之占有远远超过被传送信息所必需的最小带宽。具有较强的抗干扰、抗衰落、抗多径性能以及频谱利用率高、多址通信。

　　扩频信号具有以下三个特性:

　　1．扩频信号是不可预测的伪随机的宽带信号;

　　2．扩频信号带宽远大于欲传输数据(信息)带宽;

　　3．接收机中必须有与宽带载波同步的副本。

　  传输信息时所用信号带宽远大于传输些信息所需最小带宽的一种信号处理技术。发射端展宽频带是用独立于所传数据的码来实现，接收端用同步的相同码解扩以恢复所传数据。扩频的基本方法有，直接序列（DS）、跳频（FH）、跳时（TH）和线性调频（Chirp）等4种，目前人们所熟知的新一代手机标准CDMA就是直接序列扩频技术的一个应用。而跳频、跳时等技术则主要应用于军事领域，以避免己方通信信号被敌方截获或者干扰。扩频的主要特点为：抗干扰，抗多径衰落，低截获概率，码分多址能力，高距离分辨率和精确定时特性等。

《扩频通信数字基带信号处理算法及其VLSI实现》 张欣 第七章 扩频码序列的捕获

该文献对PN码的理论阐述比较有条理。并且给出了几种捕获的方法和VLSI结构。

一路PN码串行捕获设计--基于《通信收发信机的verilog实现与仿真》实例相关推荐

  1. 用matlab仿真导航信号,北斗卫星导航信号串行捕获算法MATLAB仿真报告(附MATLAB程序)[互联网+]...

    <北斗卫星导航信号串行捕获算法MATLAB仿真报告(附MATLAB程序)[互联网+]>由会员分享,可在线阅读,更多相关<北斗卫星导航信号串行捕获算法MATLAB仿真报告(附MATLA ...

  2. 用matlab仿真导航信号,北斗卫星导航信号串行捕获算法MATLAB仿真报告(附MATLAB程序)...

    <北斗卫星导航信号串行捕获算法MATLAB仿真报告(附MATLAB程序)>由会员分享,可在线阅读,更多相关<北斗卫星导航信号串行捕获算法MATLAB仿真报告(附MATLAB程序)(9 ...

  3. 卫星测控matlab程序,北斗卫星导航信号串行捕获算法MATLAB仿真报告(附MATLAB程序).docx...

    PAGE 4 北斗卫星导航信号串行捕获算法MATLAB仿真报告 原理 卫星导航信号的串行捕获算法如图1所示. 图1 卫星导航信号的串行捕获算法 接收机始终在本地不停地产生对应某特定卫星的本地伪码,并且 ...

  4. 北斗导航 | 北斗卫星导航信号串行捕获算法MATLAB仿真（附源代码）

    ================================================ 博主github:https://github.com/MichaelBeechan 博主CSDN:h ...

  5. 【UG NX MCD 机电一体化概念设计】UG NX MCD+PLCSIM Advanced联合仿真实例（三） 联合调试

    Step0 前言 上一篇中, 我们采用仿真序列的方式,进行了搬运逻辑的尝试,仅仅是固定一个点去放盒子,所以这篇文章将通过PLC程序控制去每一层地垒起来. Step1 MCD创建信号 信号可选择是否为运 ...

  6. FPGA系统性学习笔记连载_Day8【4位乘法器、4位除法器设计】 【原理及verilog实现、仿真】篇

    FPGA系统性学习笔记连载_Day8[4位乘法器.4位除法器设计] [原理及verilog实现.仿真]篇 连载<叁芯智能fpga设计与研发-第8天> [4位乘法器.4位除法器设计] [原理 ...

  7. FPGA系统性学习笔记连载_Day7【16位比较器设计】 【原理及verilog实现、仿真】篇

    FPGA系统性学习笔记连载_Day7[16位比较器设计] [原理及verilog实现.仿真]篇 连载<叁芯智能fpga设计与研发-第7天>[16位比较器设计] [原理及verilog实现. ...

  8. 基于单片机的TLC稳压电源系统设计-基于单片机大脑运算能力智力测试仪-基于单片机超声波测距系统仿真设计（报告 PCB 原理图）-基于单片机超高精度电参数测试设计-基于单片机变电站变压器运行参数监测仿真

    1316基于单片机的TLC稳压电源系统设计-毕设课设仿真资料 三极管射极电压是稳压电源的输出电压,可以接用电器或负载,这个电压值通过TLC549(A/D,同TLC548)数据转换后,送往单片机处理并显 ...

  9. 基于matlab的三相电路短路,终稿毕业论文设计基于MATLAB的电力系统短路故障分析与仿真.doc最终版（备份存档）...

    <[毕业论文]基于MATLAB的电力系统短路故障分析与仿真.doc>由会员分享,可免费在线阅读全文,更多与<(终稿)[毕业论文设计]基于MATLAB的电力系统短路故障分析与仿真.do ...

  10. 笔记连载 | Day7 【半加器、全加器、16位加法器、16位减法器设计】 【原理及verilog实现、仿真】篇

    听说99%的同学都来这里充电吖 本系列为线下学员学习笔记整理分享,如有想要报名参加线下培训,可以点击以下超链接文章了解,购买开发板可以到叁芯智能科技企业淘宝店下单. 各类研修班 | FPGA就业研修班 ...

最新文章

  1. 流行的9个Java框架介绍: 优点、缺点等等
  2. leanote 信息栏显示笔记本和笔记类型
  3. Python—实训day9—使用pandas进行数据预处理
  4. poj2154 Color ——Polya定理
  5. 创建与打开IPC通道的POSIX和SYSTEM V方法
  6. Jenkins 流水线 获取git 分支列表_Jenkins扩展共享库进阶
  7. STM8学习笔记---Modbus通信协议简单移植
  8. springboot flink结果输入到hbase_Flink流处理
  9. cpu风扇声音大_小米游戏本风扇声音大的处理方法
  10. php强行横屏,强制横屏app
  11. 物联网蓝牙芯片的选型
  12. 适用于Android手机的汉信码识别SDK
  13. python pdf删除图片_【原创】python批量删除pdf图片水印（Xobject）的一种方法
  14. AI实战：上海垃圾分类系列（一）之快速搭建垃圾分类模型
  15. matlab 计算物理,计算物理与MATLAB课程设计.doc
  16. 搜索引擎的设计与实现（一）从零开始？
  17. android gps nmea,读取Android GPS NMEA数据
  18. 湘南学院大学计算机专业,2019湘南学院专业排名
  19. 真狠，同事昨天被骗近50万，年底，魔鬼怪都出来吃人了。
  20. 《第七天》之第六天鼠妹和伍超为什么活不下去

热门文章

  1. 用Node.JS分析steam所有的游戏!
  2. 树莓派控制台达伺服控制器
  3. 汉源高科2个万兆光24千兆网口万兆机架式工业交换机支持G.8032（ERPS）标准的以太环网交换机
  4. Office2016专业增强版与Visio2016专业版不能共存的解决办法
  5. WinForm界面开发教程——图文并茂的界面设计
  6. SharpDX for Winform
  7. 推荐一份完整的python教学视频
  8. ac1900 linksys 恢复_把变砖的Linksys-AC1900路由器救活
  9. IDEA 代码格式化插件Save Actions示范
  10. idea Mac格式化代码快捷键