精华内容
下载资源
问答
  • 交织交织

    2013-04-07 12:06:43
    用于信道编码中交织交织 包括72位的和120位的
  • 循环交织、解交织

    2015-04-10 16:00:53
    循环交织、解交织交织时按列写入,按行读出。解交织则相反。
  • 交织与外交织

    2020-06-21 14:34:13
    交织就是turbo码编码器中的交织部分 外交织就是通信系统的交织

    内交织就是turbo码编码器中的交织部分
    外交织就是通信系统的交织器

    展开全文
  • 交织交织vhdl代码

    2010-09-09 15:52:51
    用VHDL语言编写的实现交织编码和解交织功能的代码。交织采用按行写入,按列读出的方法实现。主要包括:信源信号产生(20位的m序列),交织器,解交织器。为实现流水线的操作,采用了两个交织器和两个解交织器,当一...
  • 长度比较大的错误时很难纠错, 所以现代数字通信系统中采用交织与解交织的技术来减少数据错误的发生, 基于欧洲 标准的DVB 数字电视通信系统中, 都采用了这种交织与解交织技术。本文通过研究交织与解交织的原理, 用...
  • matlab应用代码交织器 用于排列和交织器生成的工具集合 ==interleaver== 用于对一系列典型的不同项重新排序。 例如: 1, 2, 3, 4, 5 -> 3, 2, 1, 5, 4 。 换句话说,它排列项目。 通常,伪随机排列就足够了。 在C++...
  • 交织编解码

    2018-06-01 23:04:38
    交织编码作为一种线性码,其基本思想是,通过数据交织,使得突发错误变得随机,并且错误分布于多个码字之间而不是仅仅是几个码字之间。这样每一分组的错误的数量将会降低很多,并且可以用随机纠错编码进行纠正。
  • 详细分析了PUSCH信道交织的具体过程,并根据定点TMS320C6455的特点,提出了一种简单的PUSCH信道交织与解信道交织实现方案。将程序在CCS3.3中运行,利用MATALAB软件验证了该方案的可行性和高效性。
  • 用块RAM实现卷积交织交织,fpga的实现有很大指导意义
  • 为了抗JTIDS系统通信过程中的突发性干扰,基于JTIDS的特征研究了4种交织/解交织技术,给出了抗干扰模型,运用Simulhlk建立系统的链路仿真平台,在高斯白噪声干扰方式下进行抗干扰性能仿真,通过分析4种交织/解交织...
  • 交织和解交织是组合信道纠错系统的一个重要环节,交织器和解交织器的实现方法有多种。本文利用Altera公司开发的Quartus软件平台和仿真环境,设计一种交织器和解交织器FPGA电路单倍实现的方法,并分析该电路实现的...
  • 交织与解交织的FPGA实现 介绍了数据通信中抗突发连串错码而采用交织和解交织技术。对利用实现交织器和解交织器中读写地址的产生方法进行了比较和深入的探讨。结合现场可编程门阵列器件的特点, 基于技术, 实现了按位...
  • 4.5交织

    2018-11-20 11:30:31
    4.5.1分组交织器原理 4.5.2卷积交织器原理 4.5.3 802.11a中的交织 1、符号交织的实现   2、Data交织的实现   ...mod...

    4.5.1分组交织器原理

    4.5.2卷积交织器原理

    4.5.3 802.11a中的交织

    1、符号交织的实现

     

    2、Data交织的实现

     

    https://blog.csdn.net/weiweiliulu/article/details/48160057?locationNum=9&fps=1

    代码:

    module DATA_interleaver(DINT_DIN,DINT_ND,INDEX_IN,DINT_RST,DINT_CLK,MODE_CON,DINT_DOUT,DINT_RDY);
       
        input DINT_DIN;
        input DINT_ND;
        input [8:0] INDEX_IN;
        input [1:0] MODE_CON;
        input DINT_RST;
        input DINT_CLK;
        output DINT_DOUT;
        output DINT_RDY;
    
        reg DIN;             //register of input
        reg ND;					 //enable of output
        reg [8:0] INDEX;		 //register of index for output
        reg [1:0] MODE;		 
        reg [9:0] WA_1;      //DINT_RAM_1 write address
        reg DIN_1;           //DINT_RAM_1 input register
        reg REN_1;           //DINT_RAM_1 enable read 
    	reg WEN_1;           //DINT_RAM_1 enable write
        reg WAC_1;		     //control write address of 1st interleaver
        reg DINT_RDY_1;      //DINT_RAM_1 enable output
        reg DIN_2;				 //DINT_RAM_2 input register
        reg [4:0] WA_2;		 //DINT_RAM_2 write address
        reg WEN_2;				 //DINT_RAM_2 enable write
        reg REN_2;				 //DINT_RAM_2 enable read
        reg WAC_2;				 //control write address of 2ed interleaver
        reg DINT_DV;         //enable output
        reg DINT_DOUT;		 //output register
        reg DINT_RDY;			 //synchronize with output
    
        wire [9:0] RA_1;     //DINT_RAM_1 read address
        wire [9:0] Q_1;		 //RCOUNT_1 counter of output
        wire DOUT_1;         //DINT_RAM_1 output
        wire RST;            //reset of IP core, enable under high leavel
        wire [4:0] Q_2;		 //RCOUNT_2 counter of output
        wire [4:0] RA_2;		 //DINT_RAM_2 read address
        wire DOUT_2;         //DINT_RAM_2 output
    
    	assign RST=~DINT_RST;       
    	assign RA_1=Q_1;				
    
    /********************************************************************************/
    /****************************   register for input   ****************************/
    
    always @ (negedge DINT_RST or posedge DINT_CLK)	   
    if (!DINT_RST)								 
      begin
    	  DIN<=1'b0;
    	  ND<=1'b0;
    	  INDEX<=9'b000000000;
    	  MODE<=2'b00;
      end
    else
      begin
    	  if (DINT_ND)
    		begin
    			DIN<=DINT_DIN;
    			ND<=DINT_ND;
    			INDEX<=INDEX_IN;
    			MODE<=MODE_CON;
    		end
    	  else 
    		begin
    			DIN<=1'b0;
    			ND<=1'b0;
    			INDEX<=9'b000000000;
    		end
      end
    
    
    /**********************************************************************************/
    /****************************       DINT_RAM_1   ****************************/
    
    // BRAM: depth is 384 bits, the 1st interleaver BRAM to store the data which already adjust the order
    
    DINT_RAM_1 dint_ram(
        .a(WA_1),
        .dpra(RA_1),
        .clk(DINT_CLK),
        .qdpo_clk(DINT_CLK),
        .d(DIN_1),
        .qdpo(DOUT_1),
        .qdpo_ce(REN_1),
        .qdpo_rst(RST),
        .we(WEN_1));
    
    
    /***************************************************************************/
    /****************************    RCOUNT_1    ****************************/
    
    // counter cycle is 384 to generate read address of DINT_RAM_1
    										  
    rcount_1 RCOUNT_1(
        .Q(Q_1),
        .CLK(DINT_CLK),
        .CE(REN_1),                                           
        .SCLR(RST));
    
    
    /**********************************************************************************/
    /****************************       1st interleaver    ****************************/
    
    always @ (negedge DINT_RST or posedge DINT_CLK)	   
    if (!DINT_RST)								 
      begin
    	  WAC_1<=1'b0;
    	  WA_1<=10'b0000000000;
    	  WEN_1<=1'b0;
    	  DIN_1<=1'b0;
    	  REN_1<=1'b0;
    	  DINT_RDY_1<=1'b0;
      end
    else
      begin
    	  if (REN_1)                                               
    		DINT_RDY_1<=1'b1;  				         		    
    	  else										    
    		DINT_RDY_1<=1'b0;
    	  
    	  case (MODE)									      
    		  2'b10: 
    			begin
    				if (ND)                                                  
    				  begin
    					  if (!WAC_1)	
    					       begin					// input data write in the BRAM first half part and the end alternatively, under control of WAC_1. 		
                                 WA_1<=(INDEX[3:0]<<3)+(INDEX[3:0]<<2)+INDEX[8:4];
                                 DIN_1<=DIN;
    							 WEN_1<=1'b1;
    						   end						
    					  else	
                            begin					 
    							WA_1<=(INDEX[3:0]<<3)+(INDEX[3:0]<<2)+INDEX[8:4]+192;                       														
    							WEN_1<=1'b1;									                                       
    							DIN_1<=DIN;			
                            end						
    					 if(INDEX ==9'd192)
    						begin
    							WAC_1 <= ~WAC_1;
    							REN_1 <= 1'b1;
    						end
    					 					 
    				  end
    				else 
    				  begin
    					  WA_1<=10'b0000000000;
    					  WEN_1<=1'b0;														                                       
    					  DIN_1<=1'b0;
    				  end
    				  
    				if (Q_1==191 || Q_1==383)                  //finish read of BRAM
    				  REN_1<=1'b0;								    
    			end								              
    	  endcase
    
    	  
      end
    
    
    /******************************************************************************/
    /****************************       DINT_RAM_2     ****************************/
    
    // BRAM: depth is 32bits, as 2ed interleaver, change the write address too
    
    DINT_RAM_2 dint_ram2(
        .a(WA_2),
        .clk(DINT_CLK),
        .d(DIN_2),
        .we(WEN_2),
        .qdpo_ce(REN_2),
    	.dpra(RA_2),
        .qdpo_clk(DINT_CLK),                                       
        .qdpo(DOUT_2),                                          
        .qdpo_rst(RST));
    
    
    /***************************************************************************/
    /****************************       WCOUNT_2    ****************************/
    										  
    count24 WCOUNT_2 (
        .Q(Q_2),
        .CLK(DINT_CLK),
        .CE(DINT_RDY_1),
        .SCLR(RST));
    
    
    /**********************************************************************************/
    /****************************       RCOUNT_2     ****************************/
    
    										  
    count24 RCOUNT_2 (
        .Q(RA_2),									   
        .CLK(DINT_CLK),
        .CE(REN_2),								    
        .SCLR(RST));
    
    
    /**********************************************************************************/
    /****************************      2ed interleaver     ****************************/
    
    always @ (negedge DINT_RST or posedge DINT_CLK)	   
    if (!DINT_RST)								 
      begin
    	  WEN_2<=1'b0;
    	  DIN_2<=1'b0;
    	  WAC_2<=1'b0;
    	  WA_2<=5'b00000; 
    	  REN_2<=1'b0;
    	  DINT_DV<=1'b0; 
    	  DINT_DOUT<=1'b0;
    	  DINT_RDY<=1'b0;
      end
    else
      begin
    	  case (MODE)									     
    		  2'b10:
    			  begin
    				  if (DINT_RDY_1)								    //input data to the 2ed interleaver after finish the 1st interleaver
    					begin
    						WEN_2<=1'b1;								    
    						DIN_2<=DOUT_1;							    
    						if (WAC_2)									    //process the input data, change the write address or not with 12bits cycle alternatively, under control of WAC_2
    						  begin 
    							 WA_2[4:1]<=Q_2[4:1];						    
    							 WA_2[0]<=~Q_2[0];
    						  end
    						else
    						     WA_2<=Q_2;   								    
    					end
    				  else 
    					begin
    						WEN_2<=1'b0;
    						DIN_2<=1'b0; 
    					end
    
    				  if (Q_2==11 || Q_2==23)						  //finish write, begin to read
    					begin										    
    						WAC_2<=~WAC_2;
    						REN_2<=1'b1;
    					end
    
    				  if (RA_2==23 && !DINT_RDY_1)                             
    					REN_2<=1'b0;								    
    			  end										    
    	  endcase										   
    
    	  if (REN_2)                                               
    		DINT_DV<=1'b1;
    	  else
    		DINT_DV<=1'b0;
    	  if (DINT_DV)									     //data output
    		begin										   
    			DINT_DOUT<=DOUT_2;						        	    
    			DINT_RDY<=1'b1;    							    
    		end 										    
    	  else
    		begin
    			DINT_DOUT<=1'b0;
    			DINT_RDY<=1'b0;
    		end
      end
    
    endmodule

    tb:

    `timescale 1ns/1ns
    module DATA_interleaver_tb();
        reg DINT_DIN;
        reg DINT_ND;
        reg [8:0] INDEX_IN;
        reg [1:0] MODE_CON;
        reg DINT_RST;
        reg DINT_CLK;
        wire DINT_DOUT;
        wire DINT_RDY;
        
        DATA_interleaver DATA_interleaver_inst(
        .DINT_DIN(DINT_DIN),
        .DINT_ND(DINT_ND),
        .INDEX_IN(INDEX_IN),
        .DINT_RST(DINT_RST),
        .DINT_CLK(DINT_CLK),
        .MODE_CON(MODE_CON),
        .DINT_DOUT(DINT_DOUT),
        .DINT_RDY(DINT_RDY)
        );
    	
    	integer i=0;
    	integer j=0;
        initial begin
    		DINT_RST=0;
    		DINT_CLK=0;
    		MODE_CON = 2'b00;
    		INDEX_IN = 9'b000000000;
    		DINT_ND = 0;
    		DINT_DIN = 0;
    		#20.1
    		DINT_RST = 1;
    		MODE_CON = 2'b10;
    		DINT_ND = 1;
    		#5
    		for (i=0;j<2;j=j+1)
    		    #1000
    		    begin
    				for (i=0;i<384;i=i+1)
    					begin
    						#5
    						DINT_DIN = {$random} % 2;
    						INDEX_IN = i + 9'd1;
    						DINT_ND = 1;
    					end
    				DINT_ND = 0;
    		    end
    		
    		#1000000
    		$stop;
        end
    
        always #5 DINT_CLK =  ~DINT_CLK;
     
    
    
    endmodule

     

     

    第一级交织:交织公式的地址读入,顺序读出

    第二级交织:每24个数据为一组,12个数据顺序不变,后12个数据每相邻两个交换位置

    注意:采样时钟是否能采到相应的值,笔者进行测试的时候,采样时钟,未能采到191,后改正。

     

     

     

     

     

     

     

     

     

     

    展开全文
  • end%jiaozhi.m 卷积交织函数function [bb]=jiejiaozhi(aa,n)%jiejiaozhi.m 解卷积交织函数%n=28%aa 解卷积交织前原分组序列%bb 解卷积交织后分组序列%序号重排方式:cc=[ 1 23 17 11 5 17 21 8 2 24 18 12 6 28 15 9...

    for i=1:n

    aa(i)=bb(cc(i));

    end

    %jiaozhi.m 卷积交织函数

    function [bb]=jiejiaozhi(aa,n)

    %jiejiaozhi.m 解卷积交织函数

    %n=28

    %aa 解卷积交织前原分组序列

    %bb 解卷积交织后分组序列

    %序号重排方式:

    cc=[ 1 23 17 11 5 17 21 8 2 24 18 12 6 28 15 9 3 25 19 13 7 22 16 10 4 26 20 14 ];

    for i=1:n

    bb(cc(i))=aa(i);

    end

    %jiejiaozhi.m 解卷积交织函数

    特别的,本次仿真还采用了一种循环等差交织编码。所谓循环等差,是指将序号从大到小顺时针排成一圈,从1开始等间隔逆时针取28个数,间隔为4,这样依次取的28个数即序号重排方式。

    性能参数如下:

    交织矩阵:???

    ???????????61116212638131823285101520252712172227491419241

    分组交织前序号:

    [ 1 2 3 4 5 6 7 8 9 10 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 ];

    循环等差交织后序号重排:

    [ 1 24 19 14 9 4 27 22 17 12 7 2 25 20 15 10 5 28 23 18 13 8 3 26 21 16 11 6];

    性能分析:

    1. 任何长度小于等于M + 3 = 7 + 3 =10的突发差错,经交织、去交织后

    成为独立差错。

    2. 任何长度大于M + 3 = 7 + 3 =10的突发差错,经交织、去交织后有可

    能变成短突发差错。

    3. 特殊的,间隔为M + 3 = 7 + 3 =10的独立差错,经交织、去交织后会

    变成长度为N - 1= 4 – 1 =3的突发差错。

    4. 特殊的,间隔为…4、5、4、5…的独立差错,经交织、去交织后会变

    成长度为5或6的突发差错。

    从前3条性能分析的比较看,循环等差交织比卷积交织更好。但是从第4条看,

    循环等差交织比卷积交织又差了。因此,只能通过实际仿真来比较两种交织方式的性能(见下文级联码部分)。

    展开全文
  • 交织型层级复杂网

    2021-03-28 02:39:26
    为研究两个异质关联网络复合后的结构特征与节点中心性特征,本文提出了交织型层级复杂网络的概念,可描述由两个具有部分相同节点,连接边属性近似的子网所构成的层级复杂网络,并定义了节点交织系数、路径交织系数和网络...
  • 4.3.3 交织

    千次阅读 2018-10-24 16:01:11
    4.3.3 交织  交织是为了在时域或频域或者同时在时域、频域上分布传输的信息比特,使信道的突发错误在时间上得以扩散,从而使得译码器可以将它们当作随机错误处理。    通信系统的交织模式取决于信道特性。如果...

    4.3.3 交织

     交织是为了在时域或频域或者同时在时域、频域上分布传输的信息比特,使信道的突发错误在时间上得以扩散,从而使得译码器可以将它们当作随机错误处理。

     

            通信系统的交织模式取决于信道特性。如果系统在一个纯粹的AWGN环境下运行,即准平稳信道,那么在一个数据包的持续时间上基本没有什么变化,就不需要交织。因为这时,通过重新分配的方法是无法改变误码分布的。

     

            交织必然在系统中引入延时,这时因为接受到的比特顺序与信息源发送时的顺序是不相同的。通信系统通常规定所能容忍的最大延时,因此也限制了所能使用的交织器的交织深度。

     

            经常使用的二种交织器分别为分组交织器和卷积交织器。

     

    4.3.3 交织 - fantasy - 悠然见南山

     

    4.3.3 交织 - fantasy - 悠然见南山

     

    4.3.3 交织 - fantasy - 悠然见南山

     


            在IEEE 802.11a中的交织深度等于一个OFDM符号,因此这是一个分组交织器。交织深度与所采用的调制方式有关:BPSK、QPSK、16QAM和 64QAM的交织深度分别是 48、96、192 和 288个比特,每种调制方式的交织深度是通过数据子载波的数量与每个符号中比特的个数相乘而得到的。

     

            signal域  和 data域符号的数据采用的调制方式是不同的,因此其交织方式也不同。

     


     

    A、signal 符号交织的实现

     

           signal 符号是BPSK调制,因此其交织器 signal interleaver只涉及第一级变换,其作用是:保证相邻的编码比特被映射到不相邻的子载波上,具体的变换公式为:

    4.3.3 交织 - fantasy - 悠然见南山        

    其中,k为交织前的编码比特标号;i是交织后的标号;signal interleaver中Ncbps 为 48。

    通俗的说:就是一个标准的块交织,交织深度是48,数据列写入,行读出。

     

    硬件实现:

       用一块双口RAM,采用写地址乱序,读地址顺序的方式,即按照交织后的顺序写入到RAM中,然后再依次读出。

     

    4.3.3 交织 - fantasy - 悠然见南山

     

    4.3.3 交织 - fantasy - 悠然见南山

     

     

    verilog代码已经重要部分解释:

     

    4.3.3 交织 - fantasy - 悠然见南山

     


    B、data 符号交织的实现

          data 符号交织器的实现以16QAM调制为例,data 符号的整个交织处理过程分为两级。第一级为标准的分组交织器,原理和signal 符号交织相同,交织深度是192 bits。

     

          第二级交织处理的算式:(可参考《GB 15629.1101-2006》)

     

    4.3.3 交织 - fantasy - 悠然见南山

     

            通俗的讲就是:每24个比特为一个单元,前12个顺序保持不变,后12个每相邻两位交换位置,这样就保证了相邻的编码比特被分别映射到星座图中的重要和次要位置,因此LSB长时间的低可靠性将被避免。

     

    verilog代码以及重要部分解释:

     

    第一级交织:

     

    4.3.3 交织 - fantasy - 悠然见南山

     

    第二级交织:

     

    4.3.3 交织 - fantasy - 悠然见南山

    展开全文
  • 采用了构造计数器来生成SRAM的读写地址的方法,设计了一种符合DVB-C标准,面向RS(204,188)码的卷积交织和解交织器,交织深度为12,单元深度为17。这种卷积交织和解交织器结构简单,性能良好,由于采用了单端口RAM,...
  • 点线交织

    2018-07-18 18:25:28
    拉动任意一条线段并固定到某一圆点,从而将其划分成两条新的线段,线段之间不能相交或重叠, 而新的线段又可以继续划分,如此反复,几条普通的线段就能编织出无数种奇妙的图形, ...点线交织-...
  • 交织编码

    千次阅读 2016-10-16 21:50:05
    实际上,交织编码是两个过程,交织过程,以及前向纠错FEC。FEC是检测离散的错误的,具有纠错功能,和信源编码是两个过程。 交织编码的目的是把一个较长的突发差错离散成随机差错,再用纠正随机差错的编码(FEC)...
  • 行业分类-电子电器-一种基于FPGA的天线数据交织和解交织方法.zip
  • 交织基数为M,交织深度为I的卷积交织/解交织程序,延时为I*(I-1)*M. 1 #include <iostream> 2 #include <vector> 3 #include <list> 4 #include <cstdint> 5 6 using ...
  • 按字节交织

    2013-01-10 22:45:04
    VHDL实现按字节交织交织深度为4.仿真过程序没问题。
  • 交织技术的FPGA实现

    2018-12-24 16:36:19
    该篇文章详细的介绍了卷积交织编码技术研究在FPGA上的应用与实现,对于研究交织技术有着重要的参考意义
  • verilog程序 交织2位交织器2位交织器2位交织器2位交织器2位交织器2位交织器2位交织器2位交织器2位交织器2位交织
  • 当调制方式为16-AQM,64-QAM和256-QAM时需要做位交织交织的目的是将突发的错误分散开来,把一个较长的突发差错离散成随机差错,再用随机差错的编码(FEC)等信道编码技术消除随机差错,提高通信的可靠性。交织的越深...
  • FPGA解交织

    2014-03-05 09:19:44
    FPGA解交织verilog代码实现,只提供了实现代码,仿真不在这个文档。
  • 两条光线交织Canvas特效是一款彩色发光的光线交织背景动画特效。
  • 在IDMA系统中,交织序列区分不同用户,其产生是随机且独立的。但一些交织序列互相关系数接近1,这严重影响通信性能。因此提 出一种应用于IDMA通信系统中的粒子群交织算法。该方法以互相关矩阵作为适应度 函数,采用...
  • 交织与解交织的算法研究及FPGA实现 交织与解交织的算法研究及FPGA实现 交织与解交织的算法研究及FPGA实现 交织与解交织的算法研究及FPGA实现 交织与解交织的算法研究及FPGA实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,083
精华内容 10,033
关键字:

交织