朽月

基于FPGA交织的实现

项目简述
数学模型

校验位交织
码组的列旋转交织

交织的MATLAB实现
交织的FPGA实现

FPGA代码
交织的GPGA测试代码

小结
参考文献
总结

项目简述

交织多么好听的名字，第一次听见这个名字是在移动通信的课程中，当时就对这个名字一亮。交织其实就是把原有的码元顺序打乱进行发送，说白了就是矩阵变换。至于为什么要把原有的码元顺序打乱，是因为现实中传送的码元每一段都有固定的校验位，通过该校验位可以在码元错误较少的情况下进行纠错。而实际中受环境影响的码元是突发性错误，那么我们先经过交织之后传送的码元产生的突发性错误，经过解交织之后就会把原有的突发性错误转变成离散性错误，那么就可以有效的利用校验位进行纠错。这也是交织在通信系统中起到的主要作用，即变突发性错误为随机性错误。

数学模型

从上面我们可以知道交织就是把原有的码元顺序打乱。一般的码组分为信息位和校验位，在交织的过程中，我们一般分为两步：
1、进行校验位的交织操作
2、对整个码组进行交织操作

上面两步的交织的原理并不一样，接下来分别介绍常见的交织操作。

校验位交织

校验位交织的数学公式如下：
$d_i=u_i\ \ \ \ for\ \ \ 0<=i<=K1$
$d_{K1+360t+s}=u_{K1+Q_{ldpc}s+t}\ \ \ \ \ for \ \ \ \ 0<=s<360,0<=t<=Q_{ldpc}$
其中 $i$ 是码组中第几个码元， $K 1$ 是信息位的个数， $u_i$ 是交织前的码元， $d_i$ 是交织后的输出码元， $Q_{ldpc}=校验位个数/360$ 。

依据校验位交织地址生成公式可知，校验位交织本质是行进列出，若校验位数据向量重新构成矩阵形式，交织前矩阵为Qldpc*360，即依次将向量数据每行写入 360 个数，第 361 个数为第 2 行第 1 列数，依次类推。存入 Rom 地址如图所示，

我们矩阵的时候都是一行一行的看，这里虽然本质上是列进行出，但是我们读地址是一行一行读的，所以这个就相当于矩阵的转置操作。即取数据依次以如下地址取数据，重新生成新读出矩阵。

这里隐含一个非常重要的FPGA技巧，FPGA中矩阵的转置如何使用硬件语言来描述。 等进行讲解Verilog代码的时候，可以着重注意矩阵转置对应的Verilog代码。

码组的列旋转交织

上面我们已经进行了检验位交织，将校验位交织与原来的信息位组合成的输入 $d_{i}$ 按列顺序依次写入列旋转交织器，然后按行依次读出完成列旋转交织，每列写入的起始位置由 $t c$ 决定，整个列旋转交织器：

这里解释一下与校验位交织的不同点：
1、校验位交织只有码组的校验位参与交织操作，而列旋转交织是整个码组进行交织操作
2、校验位交织的行是固定的360个元素，而列旋转交织则不是固定值
3、列旋转交织在转置的基础上，每一行均有一个tc的偏移，这也使得在书写FPGA代码的时候要比校验位交织难一点

以16QAM为例，上面的列旋交织主要有2025行8列，其中每一列的tc的值如下：

tc	0	1	2	3	4	5	6	7
16QAM	0	0	0	1	7	20	20	21

列旋转交织器的输入为 $d_i,0<=i<=N$ （其中N是整个码组的长度，在16QAM中N的长度是16200），写入列旋转交织器的 $c_m$ 列， $r_n$ 行，则行和列需要满足下面的情况(以16QAM为例)：
$c_m=i/2025$
$r_n=(i-tc)\%2025$
由上面的的公式，我们可以写出列旋交织器的输入矩阵与输出矩阵之间的关系，这里同样是按照按照行的顺序写入读出。交织前的地址是：

进行列旋交织之后的地址如下：

这里注意，FPGA的语言叫做硬件描述语言，那么要想才能成功描述上面矩阵的变化，就必须找到上面矩阵的规律，上面的公式规律已经标红，大家可以最终结合相应的FPGA代码进行学习。大家阅读下面的FPGA代码的时候，可以发现一共2025行数据，只有前21行数据是乱的，后面的2000多行数据的计算都是有规律的，这也是FPGA代码中有一个很笨重状态机的原因。大家阅读FPGA代码的时候，一定要联系上面的矩阵，可以便于理解。

交织的MATLAB实现

经过上面的原理介绍，相信大家对交织的操作有了一定的了解，那么接下来我们给出相应的MATLAB代码供大家更深入的了解。这里说明一下，代码不是博主编写，博主只是在原有的代码上进行了一些更改，可以更方便的理解代码，代码的来源是发烧友学院，在文章的最后，会附上参考网址，需要的同学可以关注一下。

sim_options = struct(...
    'CRATE_DATA',       '3/5', ...        %业务编码码率1/2 3/5 2/3 3/4 4/5 5/6   
    'CONSTELLATION', '16-QAM' ...
    );
tx_nFrame =1;


fid1 = fopen('bint_data_in.txt','r');
DataIn = fscanf(fid1,'%d');

switch sim_options.CRATE_DATA
    case '1/2',
        Q = 25;
        CR=4/9;
    case '3/5',
        Q = 18;
        CR=3/5;
    case '2/3',
        Q = 15;
        CR=2/3;
    case '3/4',
        Q = 12;
        CR=11/15;
    case '4/5',
        Q = 10;
        CR=7/9;
    case '5/6',
        Q = 8;
        CR=37/45;
    otherwise
        error('sim_options UNKNOWN CODING RATE');
end
    %------------------------------------------------------------------------------
    % PLP-specific Parameters Definition
    %------------------------------------------------------------------------------
    CONSTEL  = sim_options.CONSTELLATION;     % modulation constellation
    COD_RATE = CR;
    S        = 360;   % The S of the code
    CRATE    = sim_options.CRATE_DATA;             % The code rate
    %------------------------------------------------------------------------------
    % Procedure
    %---------------------------------------
    data = DataIn';
    nbint_len  = 16200  ; %  block size, need to pass this in
    int_type = 2;
    parity_only = false;
    Nc = 8;
    switch CONSTEL
        case 'QPSK'
                int_type = 0;
        case '16-QAM'
            Tc = [0	0	0	1	7	20	20	21];
    end
    Nr = nbint_len / Nc;
    numIntlvBlocks = floor(length(data)/nbint_len); % Number of interleaving blocks
    data = data(1:numIntlvBlocks*nbint_len); %clip the length of the input data
    bitIntlvOut = zeros(1,length(data),'single'); %mem preallocation

    if int_type == 0
      %do no interleaving
      bitIntlvOut = data;
    elseif  int_type == 2
      %the type B interleaver
      plen = round(nbint_len * (1 - COD_RATE));
      %make the parity interleaving table
      parity_table = zeros(1,plen);

      count = 1;
      for scount = 0:S-1
        for t = 0:Q-1
          parity_table(count) = S * t + scount + 1;
          count = count + 1;
        end
      end

      %compare data
      fid1 = fopen('mb_parity_addr.txt','w');
      fprintf(fid1,'%d\n',parity_table);
      
      %make the Sony interleaving table
      if ~parity_only;
          code_table = zeros(Nc, Nr);

          for cols = 1:Nc
              tc = Tc(cols);
              rw = (0:Nr-1)  -  tc;
              rwm = mod(rw, Nr) + 1;
              rwm = rwm + (cols - 1) * Nr;

              code_table(cols, :) = rwm;
          end

          code_table = reshape(code_table, Nr, []);% + 1;
          code_table = reshape(code_table, nbint_len, []);% + 1;
      end

      intered_parity = zeros(1, plen);

      for it=1:numIntlvBlocks
        %pick off the parity bits
        parity = data( (it * nbint_len) - plen + 1:it * nbint_len);

        %interleave the parity bits
        intered_parity(parity_table) = parity;

        %tack on the parity bits and interleave the whole lot
        bitIntlvWr = [data((it-1)*nbint_len+1:it* nbint_len - plen) intered_parity];

        %interleave the code word
        if ~parity_only; bitIntlvWr = bitIntlvWr(code_table); end

        % LDPC block append
        bitIntlvOut((it-1)*nbint_len+1:it*nbint_len) = bitIntlvWr;
      end

    end %if int_type == 1

    DataOut.data = bitIntlvOut;
    save bitIntlvOut.mat   bitIntlvOut

接下来对上面的代码进行简单的描述。

上面是是码组的编码率，下面是码元的调制方式，这里定义了一个结构体，进行一些全局定义。

1、引入输入码元
2、根据全局变量的定义选择不同的参数列表

1、输入码组的个数
2、根据全局变量的设置选择相应tc的值
3、其实这个程序不光可以对一个码组进行交织操作，同时可以对多个码组进行相应的交织操作。看起来程序处理的那么复杂，其实有绝大多数程序是对这方面进行相应的处理，本来博主想更改成一个码组进行处理，这样方便理解一点，但是一想，这是对源代码的不尊重，因为源代码明明功能多，自己非得降低他的功能。

1、计算校验位的个数
2、对校验位进行交织

1、计算列旋交织的输出地址

根据校验位交织、列旋交织的地址进行数据码元的变化，并取出输出码元。
上面只是简要的介绍了上面程序的大体功能，具体的需要大家联合数学原理与MATLAB代码一一相互验证，便可以真正学会该交织操作。

交织的FPGA实现

上面讲解完了交织的MATLAB实现，接下来讲解交织的FPGA实现。首先结合前面的理论知识，我先给大家画出程序框图，供大家理解整个设计。

下面整个代码是按照上面的流程进行书写的，当然上面是自己的理解，代码也不是自己书写，也只是改了一些地方。

FPGA代码

这里直接给出相应的代码，
顶层模块：

`timescale 1ns/1ps

//////////////////////////////////////////////////////////////////////////////////
 //Company: MYMINIEYE 
 //Engineer: rp lv
 //
 //Create Date: 2016/03/14 09:41:00
 //Design name:
 //Module name: tx_Bit_interleaver
 //Project name: tx_dvb_t2
 //Target Devices: zc706
 //Tool Versions: vivado 2015.1
 //Description:
 //
 //Dependencies:
 //
 //Revision: v_01
 //Revision 0.01 -File Created
 //Additional Comments
 //
 //////////////////////////////////////////////////////////////////////////////////
 `define UD #1
 
 module tx_Bit_interleaver
    (
	  input       sclk                      ,
	  input       rst_n                     ,
	  input       s_config_tvalid          ,
	  input [3:0] s_config_tdata           ,
	  input       s_data_tvalid            ,
	  input       s_data_tdata             ,
	  output reg  s_data_tready            ,
	  input       s_data_tlast             ,
	  
	  output reg  m_data_tvalid            ,
	  output reg  m_data_tdata             ,
	  input       m_data_tready            ,
	  output reg  m_data_tlast	  
	);
	
 
//========================================================================================\
//**************Define Parameter and  Internal Signals**********************************
//========================================================================================/

reg             mode_type                   ;
reg     [2:0]   code_rate                   ;
reg     [5:0]   Qldpc                       ;	
reg     [13:0]  Nbch                        ;
reg     [13:0]  Pldpc                       ;
reg     		bitInter_enb                ;
reg     [13:0]  s_data_cnt                  ;
reg     		start_parity                ;
    
reg     [13:0]  bitInter_ram_addra          ;
reg             bitInter_ram_wren           ;
reg             bitInter_ram_dina           ;
		
reg 	        bitInter_ram_wren_reg       ;
reg 	        store_over                  ;
reg 	        start_colrot_reg            ;
reg 	        start_colrot_reg2           ;
wire  	        start_colrot                ;

reg     [13:0]  bitInter_ram_addrb          ;
wire            bitInter_ram_doutb          ;
reg             colrot_valid_reg            ;
reg             colrot_valid_reg2           ;

wire    [13:0]  parity_addr                 ;
wire 		    parity_valid                ;
wire    [13:0]  colrot_addr                 ;
wire 		    colrot_valid                ;

reg             s_data_tvalid_reg           ;
wire            start_data_invld            ;

 
//========================================================================================\
//**************     Main      Code        **********************************
//========================================================================================/
	
//====================================================================================
// configure parameter
//====================================================================================
	always@(posedge sclk)
	begin
		if(~rst_n)
			begin
				mode_type <=`UD 0;
				code_rate <= `UD 0;
			end
		else if (s_config_tvalid) 
			begin
				mode_type <= `UD s_config_tdata[0];
				code_rate <= `UD s_config_tdata[3:1];
			end
	end
	  
	  
	always@(posedge sclk)
	begin
		if(~rst_n)
			Qldpc <= `UD 0;
		else
		begin
			case (code_rate)
			3'b000 : Qldpc <= `UD 6'd36; // Code Rate = 1/4;
			3'b001 : Qldpc <= `UD 6'd25; // Code Rate = 1/2;
			3'b010 : Qldpc <= `UD 6'd18; // Code Rate = 3/5;
			3'b011 : Qldpc <= `UD 6'd15; // Code Rate = 2/3;
			3'b100 : Qldpc <= `UD 6'd12; // Code Rate = 3/4;
			3'b101 : Qldpc <= `UD 6'd10; // Code Rate = 4/5;
			3'b110 : Qldpc <= `UD 6'd8;  // Code Rate = 5/6;
			default: Qldpc <= `UD 6'd25; // Code Rate = 1/2;
			endcase
		end
	end

//====================================================================================
// Processing Parity_Interleaver
//====================================================================================
    always@(posedge sclk) 
	begin
		if(~rst_n)
			Nbch <= `UD 0;
		else 
		begin
			case(code_rate)
			3'd0 : Nbch <= `UD 14'd3240;
			3'd1 : Nbch <= `UD 14'd7200;
			3'd2 : Nbch <= `UD 14'd9720;
			3'd3 : Nbch <= `UD 14'd10800;
			3'd4 : Nbch <= `UD 14'd11880;
			3'd5 : Nbch <= `UD 14'd12600;
			3'd6  : Nbch <= `UD 14'd13320;
			default:Nbch <= `UD 14'd7200;
			endcase
		end
    end	
      
      
    always@(posedge sclk)
	begin
		if(~rst_n)
			Pldpc <= `UD 0;
		else 
		begin
			case(code_rate)
			3'd0 : Pldpc <= `UD 14'd12960;
			3'd1 : Pldpc <= `UD 14'd9000;
			3'd2 : Pldpc <= `UD 14'd6480;
			3'd3 : Pldpc <= `UD 14'd5400;
			3'd4 : Pldpc <= `UD 14'd4320;
			3'd5 : Pldpc <= `UD 14'd3600;
			3'd6  : Pldpc <= `UD 14'd2880;
			default:Pldpc <= `UD 14'd9000;
			endcase
		end
    end	


		
	always@(posedge sclk)
	begin
		bitInter_enb <=`UD s_data_tvalid;
	end
	
	always@(posedge sclk)
	begin
		if(bitInter_enb)
			s_data_cnt <= `UD s_data_cnt + 1'b1;
		else
			s_data_cnt <= `UD 0;
	end
	
	always@(posedge sclk)
	begin
		if(s_data_cnt == Nbch-5'd4) // consider latency
			start_parity <= `UD 1'b1;
		else
			start_parity <= `UD 1'b0;
	end
	
	always@(posedge sclk)
	begin
		if(~rst_n)
			bitInter_ram_addra <= `UD 0;
		else if(bitInter_enb)
		begin
			if(parity_valid && mode_type == 1)
				bitInter_ram_addra <= `UD parity_addr + Nbch;
			else if(mode_type == 1)
				bitInter_ram_addra <= `UD bitInter_ram_addra + 1'b1;
			else if(mode_type == 0)
				bitInter_ram_addra <= `UD bitInter_ram_addra + 1'b1;
		end
		else
		begin
			bitInter_ram_addra <= `UD 0;
		end
	end
	

	always@(posedge sclk)
	begin
		bitInter_ram_wren <=`UD s_data_tvalid;
		bitInter_ram_dina <=`UD s_data_tdata;
	end
	

	always@(posedge sclk)
	begin
		bitInter_ram_wren_reg <=`UD bitInter_ram_wren;
	end
	always@(posedge sclk)
	begin
		if(~rst_n || start_colrot)
			store_over <= `UD 1'b0;
		else if(~bitInter_ram_wren && bitInter_ram_wren_reg)
			store_over <= `UD 1'b1;
	end
	
	always@(posedge sclk)
	begin
		if(~rst_n)
			start_colrot_reg <= `UD 0;
		else if(m_data_tready && store_over)
			start_colrot_reg <= `UD 1;
		else
			start_colrot_reg <= `UD 0;
	end
	
	always@(posedge sclk)
	begin
		start_colrot_reg2 <=`UD start_colrot_reg;
	end
	
	assign start_colrot = ~start_colrot_reg2 && start_colrot_reg;
	
	
	always@(posedge sclk)
	begin
		if(~rst_n)
			bitInter_ram_addrb <=`UD 0;
		else if(mode_type == 0 && colrot_valid_reg && bitInter_ram_addrb < 14'd16199) // QPSK
			bitInter_ram_addrb <=`UD bitInter_ram_addrb + 1'b1;
		else if(mode_type == 1) //16 QAM
			bitInter_ram_addrb <=`UD colrot_addr;
		else
			bitInter_ram_addrb <=`UD 0;
	end
	
	always@(posedge sclk)
	begin
		colrot_valid_reg <= `UD colrot_valid;
		colrot_valid_reg2 <= `UD colrot_valid_reg;
		m_data_tvalid <= `UD colrot_valid_reg2;
	end
	always@(posedge sclk)
	begin
		m_data_tdata <= `UD bitInter_ram_doutb;
	end
	
	always@(posedge sclk)
	begin
		if(~colrot_valid_reg && colrot_valid_reg2)
			m_data_tlast <= `UD 1'b1;
		else
			m_data_tlast <= `UD 1'b0;
	end
	

	
	always@(posedge sclk)
	begin
		s_data_tvalid_reg <= `UD s_data_tvalid;
	end
	
	assign start_data_invld = ~s_data_tvalid_reg && s_data_tvalid;
	
	always@(posedge sclk)
	begin
		if(~rst_n)
			s_data_tready <= `UD 0;
		else if(s_config_tvalid)
			s_data_tready <= `UD 1;
		else if(start_data_invld)
			s_data_tready <= `UD 0;
		else if(m_data_tlast)
			s_data_tready <= `UD 1;
	end
	
    
 parity_bom_addr_gen parity_bom_addr_gen
	(
	.sclk(sclk),            //input  			  
	.rst_n(rst_n),           //input  			  
	.Qldpc(Qldpc),          //input [5:0] 	  
	.Pldpc(Pldpc),          //input [13:0]      
	.start_parity(start_parity),   //input  			  
	.parity_addr(parity_addr),    //output reg [13:0] 
	.parity_valid(parity_valid)    //output reg        
	);

 ColRot_bom_addr_gen ColRot_bom_addr_gen
 (
	.sclk(sclk),             // input  		      
	.rst_n(rst_n),             //input   	      
	.start_colrot(start_colrot),    // input   	      
	.colrot_addr(colrot_addr),    //  output reg [13:0] 
	.colrot_valid(colrot_valid)    //  output reg 	   	  
 );
 
ldpc_ram ldpc_ram 
(
	.clka(sclk), // input clka
	.wea(bitInter_ram_wren), // input [0 : 0] wea
	.addra(bitInter_ram_addra), // input [13 : 0] addra
	.dina(bitInter_ram_dina), // input [0 : 0] dina
	.clkb(sclk), // input clkb
	.addrb(bitInter_ram_addrb), // input [13 : 0] addrb
	.doutb(bitInter_ram_doutb) // output [0 : 0] doutb
);


endmodule

校验位交织模块：

`timescale 1ns/1ps

//////////////////////////////////////////////////////////////////////////////////
 //Company: MYMINIEYE
 //Engineer: rp lv
 //
 //Create Date: 2016/03/14 09:41:00
 //Design name:
 //Module name: parity_bom_addr_gen
 //Project name: tx_dvb_t2
 //Target Devices: zc706
 //Tool Versions: vivado 2015.1
 //Description:
 //
 //Dependencies:
 //
 //Revision: v_01
 //Revision 0.01 -File Created
 //Additional Comments
 //
 //////////////////////////////////////////////////////////////////////////////////
 `define UD #1
 module parity_bom_addr_gen
 (
	input  			  sclk 			,
	input  			  rst_n 		,
	input [5:0] 	  Qldpc 		,
	input [13:0]      Pldpc 		,
	input  			  start_parity 	,
	output reg [13:0] parity_addr 	,
	output reg        parity_valid
 );

 
//========================================================================================\
//**************Define Parameter and  Internal Signals**********************************
//========================================================================================/
	
reg 				parity_enb 		;
reg [13:0]			parity_cnt 		;
reg [4:0] 			s_cnt 			;
reg [13:0]			S 				;
reg [13:0]			T 				;

//========================================================================================\
//************** 	Main  	Code		**********************************
//========================================================================================/
	always@(posedge sclk)
	begin
		if(~rst_n)
			parity_enb <= `UD 1'b0;
		else if(start_parity)
			parity_enb <= `UD 1'b1;
		else if(parity_cnt == Pldpc - 1)
			parity_enb <= `UD 1'b0;
	end
		
	always@(posedge sclk)
	begin
		if(~rst_n)
			parity_cnt <= `UD 0;
		else if(parity_enb)
			parity_cnt <= `UD parity_cnt + 1'b1;
		else
			parity_cnt <= `UD 0;
	end
		
	always@(posedge sclk)
	begin
		if(~rst_n)
		begin
			s_cnt <= `UD 0;
			S <= `UD 0;
		end
		else if(parity_enb)
		begin
			if(s_cnt < Qldpc - 1)
			begin
				s_cnt <= `UD s_cnt + 1'b1;
				S <= `UD  S + 14'd360;
			end
			else
			begin
				s_cnt <= `UD 0;
				S <= `UD 0;
			end
		end
		else
		begin
			s_cnt <= `UD 0;
			S <= `UD 0;
		end
	end
    
	always@(posedge sclk)
	begin
		if(~rst_n)
			T <= `UD 0;
		else if(parity_enb)
		begin
			if(s_cnt == Qldpc -1)
				T <= `UD T + 1;
		end
		else
			T <= `UD 0;
	end
		
	always@(posedge sclk)
	begin
		if(parity_enb)
			parity_addr <= `UD S + T;
		else
			parity_addr <= `UD 0;
	end
		
	always@(posedge sclk)
	begin
		parity_valid <= `UD parity_enb;
	end
	
endmodule

列旋交织模块：

`timescale 1ns/1ps

//////////////////////////////////////////////////////////////////////////////////
 //Company: MYMINIEYE
 //Engineer: rp lv
 //
 //Create Date: 2016/03/14 13:54:00
 //Design name:
 //Module name: ColRot_bom_addr_gen
 //Project name: tx_dvb_t2
 //Target Devices: zc706
 //Tool Versions: vivado 2015.1
 //Description:
 //**************************************
 //  bom_addr_gen
 //  0 2050 4050 8099 10118 12130 14155 16179
 //  1 2026 4051 6075 10119 12131 14156 16180
 //  2 2027 4052 6076 10120 12132 14157 16181
 //  ......
 //**************************************
 //Dependencies:
 //
 //Revision: v_01
 //Revision 0.01 -File Created
 //Additional Comments
 //
 //////////////////////////////////////////////////////////////////////////////////
  `define UD #1
 module ColRot_bom_addr_gen
 (
    input             sclk  			,
    input             rst_n 			,
    input             start_colrot		,
    output reg [13:0] colrot_addr		,
    output reg        colrot_valid
 );

 
//========================================================================================\
//**************Define Parameter and  Internal Signals**********************************
//========================================================================================/

    parameter  Nc  = 3'd7;
    parameter  Lcr = 14'd16033;//lcr = ldpc - Nc*21=16200 - 8*21 = 16032;
    parameter  Nr  = 11'd2025;
    
    parameter  Idle  = 24'b0000_0000_0000_0000_0000_0000;
    parameter  Row_1 = 24'b0000_0000_0000_0000_0000_0001;
    parameter  Row_2 = 24'b0000_0000_0000_0000_0000_0010;
    parameter  Row_3 = 24'b0000_0000_0000_0000_0000_0100;
    parameter  Row_4 = 24'b0000_0000_0000_0000_0000_1000;
    parameter  Row_5 = 24'b0000_0000_0000_0000_0001_0000;
    parameter  Row_6 = 24'b0000_0000_0000_0000_0010_0000;    
    parameter  Row_7 = 24'b0000_0000_0000_0000_0100_0000;
    parameter  Row_8 = 24'b0000_0000_0000_0000_1000_0000;
    parameter  Row_9 = 24'b0000_0000_0000_0001_0000_0000;
    parameter  Row_10 = 24'b0000_0000_0000_0100_0000_0000;
    parameter  Row_11 = 24'b0000_0000_0000_1000_0000_0000;
    parameter  Row_12 = 24'b0000_0000_0001_0000_0000_0000;
    parameter  Row_13 = 24'b0000_0000_0010_0000_0000_0000;
    parameter  Row_14 = 24'b0000_0000_0100_0000_0000_0000;
    parameter  Row_15 = 24'b0000_0000_1000_0000_0000_0000;
    parameter  Row_16 = 24'b0000_0001_0000_0000_0000_0000;
    parameter  Row_17 = 24'b0000_0010_0000_0000_0000_0000;
    parameter  Row_18 = 24'b0000_0100_0000_0000_0000_0000;
    parameter  Row_19 = 24'b0000_1000_0000_0000_0000_0000;
    parameter  Row_20 = 24'b0001_0000_0000_0000_0000_0000;
    parameter  Row_21 = 24'b0010_0000_0000_0000_0000_0000;
    parameter  Row_last = 24'b0100_0000_0000_0000_0000_0000;
    parameter  Gen_end  = 24'b1000_0000_0000_0000_0000_0000;
    
    parameter  Idle1 = 2'b00;
    parameter  gen1  = 2'b01;
    parameter  gen2  = 2'b10;
    
    reg [23:0]  state=0;
    reg [23:0]  state_n=0;
    reg [2:0]  Col_cal;
    reg [13:0] Row_cal;
    
    reg start_colrot_reg;
    reg start_colrot_cal;

    reg colrot_enb;
    reg [13:0]colrot_cnt;
    reg [2:0] col_cnt;
    reg [13:0]col_addr;
    reg [13:0]row_addr;
    reg [13:0]gen_taddr;
        
//====================================================================================
// Generate addr for ColRot bit and valid signal 
//====================================================================================  
  
    always@(posedge sclk)
    begin
        if(~rst_n)
            state <= `UD 0;
        else
            state <= `UD state_n;
    end
    
    always@(posedge sclk)
    begin
        start_colrot_reg <= `UD start_colrot;
        start_colrot_cal <= `UD start_colrot_reg;
    end
    
    always@(*) 
    begin
    state_n = state;
        case(state)
        Idle : if(start_colrot_cal)    state_n = Row_1;  else state_n = Idle;
        Row_1: if(Col_cal < Nc)       state_n = Row_1;  else state_n = Row_2;
        Row_2: if(Col_cal < Nc)       state_n = Row_2;  else state_n = Row_3;  
        Row_3: if(Col_cal < Nc)       state_n = Row_3;  else state_n = Row_4;         
        Row_4: if(Col_cal < Nc)       state_n = Row_4;  else state_n = Row_5; 
        Row_5: if(Col_cal < Nc)       state_n = Row_5;  else state_n = Row_6;
        Row_6: if(Col_cal < Nc)       state_n = Row_6;  else state_n = Row_7;
        Row_7: if(Col_cal < Nc)       state_n = Row_7;  else state_n = Row_8;
        Row_8: if(Col_cal < Nc)       state_n = Row_8;  else state_n = Row_9;
        Row_9: if(Col_cal < Nc)       state_n = Row_9;  else state_n = Row_10;
        Row_10: if(Col_cal < Nc)       state_n = Row_10;  else state_n = Row_11;  
        Row_11: if(Col_cal < Nc)       state_n = Row_11;  else state_n = Row_12;          
        Row_12: if(Col_cal < Nc)       state_n = Row_12;  else state_n = Row_13; 
        Row_13: if(Col_cal < Nc)       state_n = Row_13;  else state_n = Row_14;
        Row_14: if(Col_cal < Nc)       state_n = Row_14;  else state_n = Row_15;
        Row_15: if(Col_cal < Nc)       state_n = Row_15;  else state_n = Row_16;
        Row_16: if(Col_cal < Nc)       state_n = Row_16;  else state_n = Row_17;
        Row_17: if(Col_cal < Nc)       state_n = Row_17;  else state_n = Row_18;
        Row_18: if(Col_cal < Nc)       state_n = Row_18;  else state_n = Row_19;  
        Row_19: if(Col_cal < Nc)       state_n = Row_19;  else state_n = Row_20;          
        Row_20: if(Col_cal < Nc)       state_n = Row_20;  else state_n = Row_21; 
        Row_21: if(Col_cal < Nc)       state_n = Row_21;  else state_n = Row_last;
        Row_last:  if(Row_cal < Lcr)   state_n = Row_last;  else state_n = Gen_end;
        Gen_end : state_n = Idle;
        default : state_n = Idle;
        endcase
    end
  
    always@(posedge sclk)
    begin
        if(~rst_n)
            Row_cal <= `UD 0;
        else if (state_n == Row_last)
            Row_cal <= `UD Row_cal + 1'b1; 
        else 
            Row_cal <=`UD  0;
    end
  
    always @(posedge sclk) 
    begin
        case(state_n)
        Idle :  Col_cal <= `UD 0;
        Row_1: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_2: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_3: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_4: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_5: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_6: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_7: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_8: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_9: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_10: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_11: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_12: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_13: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_14: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_15: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_16: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_17: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_18: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_19: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_20: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_21: if(Col_cal == Nc)       Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;  
        Row_last:if(Row_cal == Lcr)     Col_cal <=`UD 0; else Col_cal <=`UD Col_cal + 1'b1;
        default : Col_cal <=`UD 0;
        endcase
    end
    
//====================================================================================
// Generate Rotate addr for Ldpc Block
//====================================================================================  
    always@(posedge sclk)
    begin
        case(state)
        Idle: colrot_addr <=`UD 0;
        Row_1: if (Col_cal < 3'd3)    colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_2: if (Col_cal < 3'd3)    colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
    
        Row_3: if (Col_cal < 3'd3)    colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
    
        Row_4: if (Col_cal < 3'd3)    colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
    
        Row_5: if (Col_cal < 3'd3)    colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
    
        Row_6: if (Col_cal < 3'd3)    colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
    
        Row_7: if (Col_cal < 3'd3)    colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
    
        Row_8: if (Col_cal < 3'd3)    colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_9: if (Col_cal < 3'd3)    colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_10: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_11: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_12: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_13: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_14: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_15: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_16: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_17: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_18: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_19: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_20: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_21: if (Col_cal < 3'd3)   colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr  - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr  - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr + 12'd2025 - 5'd21;
        Row_last: if (Col_cal < 3'd3) colrot_addr <=`UD gen_taddr;
            else if (Col_cal == 3'd3) colrot_addr <=`UD gen_taddr  - 5'd1;
            else if (Col_cal == 3'd4) colrot_addr <=`UD gen_taddr  - 5'd7;
            else if (Col_cal == 3'd5) colrot_addr <=`UD gen_taddr  - 5'd20;
            else if (Col_cal == 3'd6) colrot_addr <=`UD gen_taddr  - 5'd20;
            else if (Col_cal == 3'd7) colrot_addr <=`UD gen_taddr  - 5'd21;
        Gen_end : colrot_addr <=`UD 0;
        default : colrot_addr <=`UD 0;
        endcase
    end
    
//====================================================================================
// Generate normal addr , so that easy to get rotate addr
//====================================================================================  
    always@(posedge sclk)
    begin
        if(~rst_n)
            colrot_enb <= `UD 1'b0;
        else if(start_colrot)
            colrot_enb <= `UD 1'b1;
        else if(colrot_cnt == 14'd16199)
            colrot_enb <= `UD 1'b0;
    end
    
    always@(posedge sclk)
    begin
        if(~rst_n)
            colrot_cnt <= `UD 0;
        else if(colrot_enb)
            colrot_cnt <= `UD colrot_cnt + 1'b1;
        else
            colrot_cnt <= `UD 0;
    end
    
    always@(posedge sclk)
    begin
        if(~rst_n)
        begin
            col_cnt <= `UD 0;
            col_addr <= `UD 0;
        end
        else if(colrot_enb)
        begin
            if(col_cnt < Nc)
            begin
                col_cnt <= `UD col_cnt + 1'b1;
                col_addr <= `UD  col_addr + 14'd2025;
            end
            else
            begin
                col_cnt <= `UD 0;
                col_addr <= `UD 0;
            end
        end
        else
        begin
            col_cnt <= `UD 0;
            col_addr <= `UD 0;
        end
    end
  
    always@(posedge sclk)
    begin
        if(~rst_n)
            row_addr <= `UD 0;
        else if(colrot_enb )
        begin
            if(col_cnt == Nc)
                row_addr <= `UD row_addr + 1;
        end
        else
        begin
            row_addr <= `UD 0;
        end
    end
    
    always@(posedge sclk)
    begin
        if(colrot_enb)
            gen_taddr <= `UD col_addr + row_addr;
        else
            gen_taddr <= `UD 0;
    end
 //====================================================================================
// Generate Rotate addr  valid signal 
//====================================================================================  
    
    always @(posedge sclk)
    begin
        if(~rst_n)
            colrot_valid <= `UD 0;
        else if(state_n == Idle || state_n ==Gen_end)
            colrot_valid <=`UD 0;
        else
            colrot_valid <=`UD 1;
    end
    
    endmodule

上面着重说一下列旋交织模块中的状态机，我认为状态机完全可以用行计数器来代替，可以很好的减少代码的复杂度。上面的代码，博主学习了一天的时间才看懂上面的逻辑流程，但是相信经过前面的框图与原理性的介绍，大家学习可以快点。

交织的GPGA测试代码

测试代码如下：

`timescale 1ns / 1ps

////////////////////////////////////////////////////////////////////////////////
// Company: MYMINEYE
// Engineer:rplv
//
// Create Date:   11:32:55 03/15/2016
// Design Name:   tx_Bit_interleaver
// Module Name:   tb_tx_Bit_interleaver.v
// Project Name:  tx_dvb_t2
// Target Device: zc706 
// Tool versions: vivado.2015.1 
// Description: 
//
// 
//
// Dependencies:
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
////////////////////////////////////////////////////////////////////////////////

 `define UD #1
 
module tb_tx_Bit_interleaver;

	// Inputs
	reg clk;
	reg rstn;
	reg s_config_tvalid;
	wire [3:0] s_config_tdata;
	reg s_data_tvalid;
	reg s_data_tdata;
	reg s_data_tlast;
	reg m_data_tready;

	// Outputs
	wire s_data_tready;
	wire m_data_tvalid;
	wire m_data_tdata;
	wire m_data_tlast;
	
    reg s_data_tvalid1;
	reg s_data_tlast1;
	

	// Instantiate the Unit Under Test (UUT)
	tx_Bit_interleaver uut (
		.clk(clk), 
		.rstn(rstn), 
		.s_config_tvalid(s_config_tvalid), 
		.s_config_tdata(s_config_tdata), 
		.s_data_tvalid(s_data_tvalid1), 
		.s_data_tdata(s_data_tdata), 
		.s_data_tready(s_data_tready), 
		.s_data_tlast(s_data_tlast1), 
		.m_data_tvalid(m_data_tvalid), 
		.m_data_tdata(m_data_tdata), 
		.m_data_tready(m_data_tready), 
		.m_data_tlast(m_data_tlast)
	);
	
//=========================================================================
//   config parameter 
//=========================================================================		
  reg  mode_type = 1'b1;
  reg  [2:0]code_rate = 3'd2;
  
  assign s_config_tdata [0] = mode_type;
  assign s_config_tdata [3:1] = code_rate;

//=========================================================================
//   initial 
//=========================================================================	
	initial begin
		s_config_tvalid = 0;
		s_data_tvalid = 0;
		rstn = 0;
		clk = 0;
		m_data_tready = 1;

        repeat(10) @(posedge clk);#1;
        rstn = 1;
        repeat(5) @(posedge clk);#1;
        s_config_tvalid = 1;
        repeat(1) @(posedge clk);#1;
        s_config_tvalid = 0;  		
	    repeat(1) @(posedge clk);#1;
        s_data_tvalid = 1; 
        s_data_tlast = 0;  
        repeat(16200*1-1) @(posedge clk);#1;//QPSK = 8100,
        //repeat(4049) @(posedge clk);#1;//QAM = 4050;
        s_data_tvalid = 1; 
        s_data_tlast = 1;    
        repeat(1) @(posedge clk);#1;//
        s_data_tvalid = 0; 
        s_data_tlast = 0; 
	end
	
	always@(posedge clk)
	begin
	 s_data_tvalid1 <= `UD s_data_tvalid;
	 s_data_tlast1  <= `UD s_data_tlast;
	end
	
//=========================================================================
//   input
//=========================================================================	


	integer fid1;
	initial 
	
    begin
		fid1 = $fopen("bint_data_in.txt","r");
    end
	
    always@(posedge clk)
	begin
		if(s_data_tvalid)
			$fscanf(fid1,"%d",s_data_tdata);
	end
    	


 //=========================================================================
// output
//=========================================================================	
		
	integer fid2;
	initial 
	begin
		fid2 = $fopen("ms_bitInter_sim.txt","w");
	end
	
	always@(posedge clk)
	begin
		if(m_data_tvalid)
			$fwrite(fid2,"%b\n",m_data_tdata);
	end

 always #5 clk = ~clk;
 //=========================================================================
// compare addr
//=========================================================================	
wire            parity_valid = tb_tx_Bit_interleaver.uut.parity_valid;
wire signed   [13:0]   parity_addr  = tb_tx_Bit_interleaver.uut.parity_addr;

integer fid3;
initial 
begin
	fid3 = $fopen("ms_parity_addr.txt","w");
end

always@(posedge clk)
begin
	if(parity_valid)
		$fwrite(fid3,"%d\n",parity_addr+1'b1);
end 
  
endmodule

从上面我们可以看出测试代码将交织后的码元输出到一个txt文件中，然后我们就可以在MATLBA中与MATLAB生成的交织后的码元相互验证，证明FPGA侧交织的正确性。
MATLAB验证代码如下：

clc ;
clear all;
load bitIntlvOut.mat
 data_lab = bitIntlvOut;
 tx_nFrame =1;
   
   bitInter_data_lab = [data_lab'];
   
   fid1 = fopen('ms_bitInter_sim.txt','r');
   bitInter_data_sim = fscanf(fid1,'%d');
   
   start_Idx = length(bitInter_data_lab)*(tx_nFrame - 1);
   if(isempty(bitInter_data_sim))
   bitInter_data_result = 0;
   else
   bitInter_data_result = sum(abs(bitInter_data_lab - bitInter_data_sim(start_Idx+1:start_Idx+length(bitInter_data_lab))));
   end
   a = bitInter_data_result

最终测试的结果FPGA与MATLAB交织后的码元完全相同。如下图：

小结

相信大家在学习算法的FPGA实现的时候都掌握了上面的流程，就是先在MATLAB中实现，然后再在FPGA中实现，交互验证实现的正确性。

参考文献

[1]、电子发烧友学院

总结

创作不易，认为文章有帮助的同学们可以关注、点赞、转发支持。为行业贡献及其微小的一部分。或者对文章有什么看法或者需要更近一步交流的同学，可以加入下面的群：

你可能感兴趣的:(FPGA,fpga)

(179)时序收敛---＞(29)时序收敛二九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛二九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
(180)时序收敛---＞(30)时序收敛三十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
(158)时序收敛---＞(08)时序收敛八 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛八（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
(159)时序收敛---＞(09)时序收敛九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
(160)时序收敛---＞(10)时序收敛十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
(153)时序收敛---＞(03)时序收敛三 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
(121)DAC接口---＞(006)基于FPGA实现DAC8811接口 FPGA系统设计指南针 FPGA接口开发(项目实战)fpga开发 FPGA IC
1目录（a）FPGA简介（b）IC简介（c）Verilog简介（d）基于FPGA实现DAC8811接口（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电
FPGA复位专题---（3）上电复位？ FPGA系统设计指南针 FPGA系统设计(内训)fpga开发
（3）上电复位？1目录（a）FPGA简介（b）Verilog简介（c）复位简介（d）上电复位？（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限
(182)时序收敛---＞(32)时序收敛三二 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三二（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
使用FPGA接收MIPI CSI RX信号并进行去抖动、RGB转YUV处理：FX3014 USB3.0 UVC传输与帧率控制源代码，FPGA实现MIPI CSI RX接收，去Debayer， RGB转 kVfINoSzdrt fpga开发程序人生
fpgamipicsirx接收去debayer,rgb转yuv,fx3014usb3.0uvc传输与帧率控制源代码，具体架构看图，除dphy物理层外，mipi均为源码sensorimx219mipi源码mipi4lanecsirxraw10fpgamachXO3lf-690usb3.0fx301432bityuvdatawithframesync测试模式3280*246415fps1920*108
FPGA_mipi 哈呀_fpga fpga开发逻辑高速接口系统架构高速传输
1mipi接口mipi(移动行业处理器接口，是为高速数据传输量身定做的，旨在解决日益增长的高清图像(视频)传输的高带宽要求与传统接口低速率之间的矛盾。采用差分信号传输，在设计时需要按照差分设计的一般规则进行严格的设计。mipi协议提出之际，主要有2个应用，csi(摄像头串行接口)，旨在为高清摄像头和应用处理器之间提供一个高速串行接口，和dsi(显示串行接口)，旨在为应用处理器和显示设备之间提供一个
Xilinx 7系列FPGA架构之器件配置（二） FPGA技术实战 FPGA器件架构 Xinx FPGA硬件设计 fpga开发
引言：本文我们介绍下7系列FPGA的配置接口，在进行硬件电路图设计时，这也是我们非常关心的内容，本文主要介绍配置模式的选择、配置管脚定义以及如何选择CFGBVS管脚电压及Bank14/15电压。1.概述Xilinx®7系列设备有五个配置接口。每个配置接口对应一个或多个配置模式和总线宽度，如表1所示。有关接口详细的时序信息，可以参阅相应的7系列FPGA数据手册。配置时序主要与FPGA配置时钟管脚CC
Xilinx 7系列FPGA架构之器件配置（一） FPGA技术实战 FPGA器件架构 Xinx FPGA硬件设计 fpga开发
引言：本系列博文描述7系列FPGA配置的技术参考。作为开篇，简要概述了7系列FPGA的配置方法和功能。随后的博文将对每种配置方法和功能进行更详细的描述。本文描述的配置方法和功能适用于所有7系列家族器件，只有少数例外。1.概述Xilinx®7系列FPGA通过将特定于应用程序的配置数据（位流）加载到内存中进行配置。7系列FPGA可以主动从外部非易失性存储设备加载，也可以通过外部智能源（如微处理器、DS
FPGA器件在线配置方法概述 fpga和matlab FPGA 其他 fpga开发 FPGA 在线配置
目录1.配置电路结构和原理2.ICR控制电路软件3.几种常见的FPGA在线配置方法3.1动态部分重配置（PartialReconfiguration,PR）3.2在系统编程（In-SystemProgramming,ISP）3.3多比特流配置（Multi-BitstreamConfiguration）3.4远程更新与配置3.5使用OpenCL或HLS工具FPGA（Field-Programmabl
quartus频率计时钟设置_FPGA021 基于QuartusⅡ数字频率计的设计与仿真 weixin_39876739 quartus频率计时钟设置
摘要随着科技电子领域的发展，可编程逻辑器件，例如CPLD和FPGA的在设计中得到了广泛的应用和普及，FPGA/CPLD的发展使数字设计更加的灵活。这些芯片可以通过软件编程的方式对内部结构进行重构，使它达到相应的功能。这种设计思想改变了传统的数字系统设计理念，促进了EDA技术的迅速发展。数字频率计是一种基本的测量仪器。它被广泛应用与航天、电子、测控等领域。采用等精度频率测量方法具有测量精度保持恒定，
quartus pin 分配（三）落雨无风 IC设计 fpga fpga开发
quartuspin分配如有需要，可查看quartusUI界面sdc配置（二）上次文章中，说了自己写sdc需要配置的分类点，这次将介绍管脚分配。已打开Quartus软件，导入设计，写好约束下一步，在Quartus软件的菜单栏打开Assignments中的二级菜单PinPlanner打开改界面即可看到选中的fpga型号，管脚图，封装类型等信息。在打开的界面中，大致可分为上下两个部分。上半部分，可分为
FPGA随记——赛灵思OOC功能一口一口吃成大V FPGA随记 fpga开发
在这里，我们简要介绍一下Vivado的OOC（Out-of-Context）综合的概念。对于顶层设计，Vivado使用自顶向下的全局（Global）综合方式，将顶层之下的所有逻辑模块都进行综合，但是设置为OOC方式的模块除外，它们独立于顶层设计而单独综合。通常，在整个设计周期中，顶层设计会被多次修改并综合。但有些子模块在创建完毕之后不会因为顶层设计的修改而被修改，如IP，它们被设置为OOC综合方式
如何设计实现完成一个FPGA项目芯作者 D1：verilog设计 D1：VHDL设计 fpga开发
设计并完成一个FPGA项目是一个复杂但非常有价值的工程任务。以下是一个详细的步骤指南，帮助你从零开始完成一个FPGA项目。1.项目定义与需求分析确定项目目标：明确项目要实现的功能和性能指标。需求分析：列出所有功能需求、性能需求、接口需求等。可行性分析：评估技术可行性、成本和时间预算。2.硬件选择FPGA芯片选择：根据项目需求选择合适的FPGA芯片（如Xilinx、Intel/Altera、Latt
零配置初始化流程就一直过不去_ZYNQ UltraScale+ MPSoc FPGA自学笔记-启动加载配置... weixin_40009026 零配置初始化流程就一直过不去
前言听说最近秋天的第一杯奶茶挺火的，我得赶紧奋发图强写点东西，好赚点赏钱给妹子买奶茶，各位大佬出手大方点，我怕秋天过去了妹子还没喝上奶茶！言归正传，ZYNQUltraScale+MPSoc的配置过程还是挺复杂的，决定写一篇文章来讲一讲，当然我也是初学，如有错讹请轻轻打左脸。一、配置过程Zynq®UltraScale+™MPSoC同时有PS端和PL端，PS又有两种不同的多核处理器可以运行底层代码或者
FPGA编程指南: CSU DMA传输行者.................. fpga开发 FPGA
1.将安全流开关配置设置为从DMA源接收，即设置csu.csu_sss_cfg[pcap_sss]为0x5。2.配置并设置CSU_DMA以建立通道和传输，具体编程方法可参考CSUDMA编程部分。-通道类型为DMA_SRC。-设置源地址为位流的地址。-设置大小为以字表示的位流大小。3.等待CSUDMA操作完成，确保源频道的传输已完成。4.清除CSU_DMA中断并确认传输完成，这需要设置csudma.
FPGA案例小程序 BABA8891 fpga开发小程序
FPGA（Field-ProgrammableGateArray，现场可编程门阵列）的应用广泛，因此存在许多不同领域的案例小程序。以下是一些FPGA案例小程序的示例，涵盖了不同的应用场景：1.串口闭环收发小程序应用场景：工业自动化、通信设备、仪器仪表等。功能描述：该小程序通过FPGA芯片的编程实现串口数据的接收和发送功能，支持9600和115200两种速率。在接收数据时，FPGA通过串行接口接收外
电源管理芯片4644关键指标及测试方法国科安芯产品 fpga开发嵌入式硬件硬件工程
以国科安芯(ANSILIC)推出四通道输出降压微型模块稳压器ASP4644为例，该器件支持多路级联输出最高16A。工程师可以快速设计出满足FPGA、ASIC和微处理器等多种电压和负载电流要求驱动，ASP4644模块稳压器包括DC/DC控制器、电源开关、电感器和补偿组件，采用BGA封装。仅需8个外部陶瓷电容器和4个反馈电阻器就能调节4个可独立地调整并介于0.6V至5.5V的输出。单独的输入引脚使4个
FPGA（Field-Programmable Gate Array，现场可编程门阵列）开发入门 MAMA6681 fpga开发
FPGA（Field-ProgrammableGateArray，现场可编程门阵列）开发入门是一个系统且深入的过程，涉及到硬件设计、编程语言、开发工具等多个方面。以下是一个简要的FPGA开发入门指南：一、基础知识准备数字电路与逻辑设计：了解数字电路的基本概念，如二进制、逻辑门电路、组合逻辑电路、时序逻辑电路等。熟悉布尔代数和逻辑门的功能及其实现方法。计算机体系架构：掌握CPU、内存、外设、总线等计
FPGA 编程基础, 赋值操作符, 运算符使用, 条件表达式, 信号操作方法行者.................. fpga开发
1.**赋值符号**：-**"="**：阻塞赋值，即在`always`模块中该语句会被立即执行。-**""**：大于，如果A>B则结果为TRUE，否则为FALSE。-**">="**：大于等于，如果A>=B则结果为TRUE，否则为FALSE。-**"=="**：等于，如果A==B则结果为TRUE，否则为FALSE。-**"!="**：不等于，如果A!=B则结果为TRUE，否则为FALSE。4.**
zobovision随谈H.265/HEVC编码FPGA实现（一） zobovision 视频图像编解码FPGA IP fpga开发视频编解码
zobovision随谈H.265/HEVC编码FPGA实现（一）H.265/HEVC出来已有10年，但市场应用难言巅峰，正如古董级的H.264现在仍然大行其道，H.265的全面应用仍有待市场发酵，至少在硬件产品端应用，值得期待。一来H.265相对H.264而言，压缩技术确实要先进不少，不管是理论上还是实际效果方面；二是H.265相对后来者H.266/VVC等而言，实用性更强，性价比更高，产品端的
(14)时钟专题---＞(014)行波时钟宁静致远dream FPGA学无止境 fpga开发 FPGA IC
1.1.1本节目录1）本节目录2）本节引言3）FPGA简介4）行波时钟5）结束语1.1.2本节引言“不积跬步，无以至千里；不积小流，无以成江海。就是说：不积累一步半步的行程，就没有办法达到千里之远；不积累细小的流水，就没有办法汇成江河大海。1.1.3FPGA简介FPGA（FieldProgrammableGateArray）是在PAL、GAL等可编程器件的基础上进一步发展的产物。它是作为专用集成电
在Xilinx FPGA上快速实现 JESD204B 长弓的坚持总线接口协议存储
简介JESD204是一种连接数据转换器（ADC和DAC）和逻辑器件的高速串行接口，该标准的B修订版支持高达12.5Gbps串行数据速率，并可确保JESD204链路具有可重复的确定性延迟。随着转换器的速度和分辨率不断提升，JESD204B接口在ADI高速转换器和集成RF收发器中也变得更为常见。此外，FPGA和ASIC中灵活的串行器/解串器(SERDES)设计正逐步取代连接转换器的传统并行LVDS/C
【【通信协议之MDIO读写的FPGA实现】】 ZxsLoves FPGA学习 fpga开发
通信协议之MDIO读写的FPGA实现介绍MAC与PHY之间的通信通过了MDIO的接口与PHY芯片的通信则通过MAC（MediaAccessControl）控制器来实现。MAC控制器与PHY芯片之间的通信通常包括两部分：1.数据传输接口：比如MII（MediaIndependentInterface）、RMII（ReducedMediaIndependentInterface）、GMII（Gigab
8B10B编解码及FPGA实现 weixin_34309435
概述在使用ALTERA的高速串行接口时，GXB模块里硬件实现了8B10B编码，用户只是“傻瓜”式的使用，笔者也一直没有弄清楚。网上搜索了一些学习资料，结合参考文献希望能够对其进行消化。另外，ALTERA现在已经提供8B10BIP，用户可以直接使用，不过有时候为了代码可移植性需要自己写代码实现8B10B编解码，笔者希望在这方面也做些实践。8B10B编码概念基本概念网上可以轻易找到答案，简单的说就是将
FPGA设计中的电源管理(转载） weixin_30632089 嵌入式数据库
过去，FPGA设计者主要关心时序和面积使用率问题。但随着FPGA不断取代ASSP和ASIC器件，设计者们现正期望能够开发低功耗设计，在设计流程早期就能对功耗进行正确估算，以及管理和对与FPGA相关的各种内部电压及I/O电压排序。电源管理已成为FPGA设计者的一个重要考虑因素，特别是在设计便携式、电池供电的产品时。通过功率监控设计技术能够减少功耗、增强可靠性、降低生产成本，并减少对电源和冷却的要求。
继之前的线程循环加到窗口中运行 3213213333332132 java thread JFrame JPanel
之前写了有关java线程的循环执行和结束，因为想制作成exe文件，想把执行的效果加到窗口上，所以就结合了JFrame和JPanel写了这个程序，这里直接贴出代码，在窗口上运行的效果下面有附图。 package thread; import java.awt.Graphics; import java.text.SimpleDateFormat; import java.util
linux 常用命令 BlueSkator linux 命令
1.grep 相信这个命令可以说是大家最常用的命令之一了。尤其是查询生产环境的日志，这个命令绝对是必不可少的。但之前总是习惯于使用（grep -n 关键字文件名）查出关键字以及该关键字所在的行数，然后再用（sed -n '100,200p' 文件名），去查出该关键字之后的日志内容。但其实还有更简便的办法，就是用（grep -B n、-A n、-C n 关键
php heredoc原文档和nowdoc语法 dcj3sjt126com PHP heredoc nowdoc
<!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body> <?
overflow的属性周华华 JavaScript
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
《我所了解的Java》——总体目录 g21121 java
准备用一年左右时间写一个系列的文章《我所了解的Java》，目录及内容会不断完善及调整。在编写相关内容时难免出现笔误、代码无法执行、名词理解错误等，请大家及时指出，我会第一时间更正。 &n
[简单]docx4j常用方法小结 53873039oycg docx
本代码基于docx4j-3.2.0，在office word 2007上测试通过。代码如下: import java.io.File; import java.io.FileInputStream; import ja
Spring配置学习云端月影 spring配置
首先来看一个标准的Spring配置文件 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=&q
Java新手入门的30个基本概念三 aijuans java 新手 java 入门
17.Java中的每一个类都是从Object类扩展而来的。　　18.object类中的equal和toString方法。　　equal用于测试一个对象是否同另一个对象相等。　　toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.(toString 方法是一个很重要的方法)　　 19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。　
《2008 IBM Rational 软件开发高峰论坛会议》小记 antonyup_2006 软件测试敏捷开发项目管理 IBM 活动
我一直想写些总结,用于交流和备忘,然都没提笔,今以一篇参加活动的感受小记开个头,呵呵! 其实参加《2008 IBM Rational 软件开发高峰论坛会议》是9月4号,那天刚好调休.但接着项目颇为忙,所以今天在中秋佳节的假期里整理了下. 参加这次活动是一个朋友给的一个邀请书,才知道有这样的一个活动,虽然现在项目暂时没用到IBM的解决方案,但觉的参与这样一个活动可以拓宽下视野和相关知识.
PL/SQL的过程编程,异常,声明变量,PL/SQL块百合不是茶 PL/SQL的过程编程异常 PL/SQL块声明变量
PL/SQL; 过程; 符号; 变量; PL/SQL块; 输出; 异常; PL/SQL 是过程语言(Procedural Language)与结构化查询语言(SQL)结合而成的编程语言PL/SQL 是对 SQL 的扩展,sql的执行时每次都要写操作
Mockito(三)--完整功能介绍 bijian1013 持续集成 mockito 单元测试
mockito官网：http://code.google.com/p/mockito/，打开documentation可以看到官方最新的文档资料。一.使用mockito验证行为 //首先要import Mockito import static org.mockito.Mockito.*; //mo
精通Oracle10编程SQL(8)使用复合数据类型 bijian1013 oracle 数据库 plsql
/* *使用复合数据类型 */ --PL/SQL记录 --定义PL/SQL记录 --自定义PL/SQL记录 DECLARE TYPE emp_record_type IS RECORD( name emp.ename%TYPE, salary emp.sal%TYPE, dno emp.deptno%TYPE ); emp_
【Linux常用命令一】grep命令 bit1129 Linux常用命令
grep命令格式 grep [option] pattern [file-list] grep命令用于在指定的文件(一个或者多个,file-list)中查找包含模式串(pattern)的行,[option]用于控制grep命令的查找方式。 pattern可以是普通字符串，也可以是正则表达式，当查找的字符串包含正则表达式字符或者特
mybatis3入门学习笔记白糖_ sql ibatis qq jdbc 配置管理
MyBatis 的前身就是iBatis，是一个数据持久层(ORM)框架。 MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。MyBatis对JDBC进行了一次很浅的封装。以前也学过iBatis，因为MyBatis是iBatis的升级版本，最初以为改动应该不大，实际结果是MyBatis对配置文件进行了一些大的改动，使整个框架更加方便人性化。
Linux 命令神器：lsof 入门 ronin47 lsof
lsof是系统管理/安全的尤伯工具。我大多数时候用它来从系统获得与网络连接相关的信息，但那只是这个强大而又鲜为人知的应用的第一步。将这个工具称之为lsof真实名副其实，因为它是指“列出打开文件（lists openfiles）”。而有一点要切记，在Unix中一切（包括网络套接口）都是文件。有趣的是，lsof也是有着最多
java实现两个大数相加，可能存在溢出。 bylijinnan java实现
import java.math.BigInteger; import java.util.regex.Matcher; import java.util.regex.Pattern; public class BigIntegerAddition { /** * 题目：java实现两个大数相加，可能存在溢出。 * 如123456789 + 987654321
Kettle学习资料分享，附大神用Kettle的一套流程完成对整个数据库迁移方法 Kai_Ge Kettle
Kettle学习资料分享 Kettle 3.2 使用说明书目录概述..........................................................................................................................................7 1.Kettle 资源库管
[货币与金融]钢之炼金术士 comsci 金融
自古以来,都有一些人在从事炼金术的工作.........但是很少有成功的那么随着人类在理论物理和工程物理上面取得的一些突破性进展...... 炼金术这个古老
Toast原来也可以多样化 dai_lm android toast
Style 1：默认 Toast def = Toast.makeText(this, "default", Toast.LENGTH_SHORT); def.show(); Style 2：顶部显示 Toast top = Toast.makeText(this, "top", Toast.LENGTH_SHORT); t
java数据计算的几种解决方法3 datamachine java hadoop ibatis r-langue r
4、iBatis 简单敏捷因此强大的数据计算层。和Hibernate不同，它鼓励写SQL，所以学习成本最低。同时它用最小的代价实现了计算脚本和JAVA代码的解耦，只用20%的代价就实现了hibernate 80%的功能,没实现的20%是计算脚本和数据库的解耦。复杂计算环境是它的弱项，比如：分布式计算、复杂计算、非数据
向网页中插入透明Flash的方法和技巧 dcj3sjt126com html Web Flash
将 Flash 作品插入网页的时候，我们有时候会需要将它设为透明，有时候我们需要在Flash的背面插入一些漂亮的图片，搭配出漂亮的效果……下面我们介绍一些将Flash插入网页中的一些透明的设置技巧。　　一、Swf透明、无坐标控制　　首先教大家最简单的插入Flash的代码，透明，无坐标控制：　　注意wmode="transparent"是控制Flash是否透明
ios UICollectionView的使用 dcj3sjt126com
UICollectionView的使用有两种方法，一种是继承UICollectionViewController，这个Controller会自带一个UICollectionView；另外一种是作为一个视图放在普通的UIViewController里面。个人更喜欢第二种。下面采用第二种方式简单介绍一下UICollectionView的使用。 1.UIViewController实现委托，代码如
Eos平台java公共逻辑蕃薯耀 Eos平台java公共逻辑 Eos平台 java公共逻辑
Eos平台java公共逻辑 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:20:4
SpringMVC4零配置--Web上下文配置【MvcConfig】 hanqunfeng springmvc4
与SpringSecurity的配置类似，spring同样为我们提供了一个实现类WebMvcConfigurationSupport和一个注解@EnableWebMvc以帮助我们减少bean的声明。 applicationContext-MvcConfig.xml  <
解决ie和其他浏览器poi下载excel文件名乱码 jackyrong Excel
使用poi,做传统的excel导出，然后想在浏览器中，让用户选择另存为，保存用户下载的xls文件，这个时候，可能的是在ie下出现乱码（ie,9,10,11),但在firefox,chrome下没乱码，因此必须综合判断，编写一个工具类： /** * * @Title: pro
挥洒泪水的青春 lampcy 编程生活程序员
2015年2月28日，我辞职了，离开了相处一年的触控，转过身--挥洒掉泪水，毅然来到了兄弟连，背负着许多的不解、质疑——”你一个零基础、脑子又不聪明的人，还敢跨行业，选择Unity3D？“，”真是不自量力••••••“，”真是初生牛犊不怕虎•••••“，••••••我只是淡淡一笑，拎着行李----坐上了通向挥洒泪水的青春之地——兄弟连！这就是我青春的分割线，不后悔，只会去用泪水浇灌——已经来到
稳增长之中国股市两点意见-----严控做空，建立涨跌停版停牌重组机制 nannan408
对于股市，我们国家的监管还是有点拼的，但始终拼不过飞流直下的恐慌，为什么呢？笔者首先支持股市的监管。对于股市越管越荡的现象，笔者认为首先是做空力量超过了股市自身的升力，并且对于跌停停牌重组的快速反应还没建立好，上市公司对于股价下跌没有很好的利好支撑。我们来看美国和香港是怎么应对股灾的。美国是靠禁止重要股票做空，在
动态设置iframe高度(iframe高度自适应) Rainbow702 JavaScript iframe contentDocument 高度自适应局部刷新
如果需要对画面中的部分区域作局部刷新，大家可能都会想到使用ajax。但有些情况下，须使用在页面中嵌入一个iframe来作局部刷新。对于使用iframe的情况，发现有一个问题，就是iframe中的页面的高度可能会很高，但是外面页面并不会被iframe内部页面给撑开，如下面的结构： <div id="content"> <div id=&quo
用Rapael做图表 tntxia rap
function drawReport(paper,attr,data){ var width = attr.width; var height = attr.height; var max = 0; &nbs
HTML5 bootstrap2网页兼容（支持IE10以下） xiaoluode html5 bootstrap
<!DOCTYPE html> <html> <head lang="zh-CN"> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge">