4.4.8 多码速卷积码硬件结构与实现

最新推荐文章于 2024-06-14 09:33:50 发布
最新推荐文章于 2024-06-14 09:33:50 发布
阅读量1.5k 收藏 16
点赞数 2
分类专栏： ofdm 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40640020/article/details/84132428
版权

理解： 

 

本工程采用的是signal域 1/2卷积编码，data域 3/4编码，所以整体为多速率的卷积编码，可以有速率选择。

模块有二个时钟，一个是输入时钟，一个是输出时钟（按照所得速率不同而不同）。

signal域，输入时钟（20M），输出时钟（40M）。

data域， 输入时钟（60M），输出时钟（80M）。

模块思想是：首先生成1/2码率的卷积码，然后缓存起来，根据不同的速率要求，给予不同的输出方式。

 1.Convolution Encoder模块

 

 

1、参考【GB 15629.1101-2006 第11部分 无线局域网媒体访问控制和物理层规范.pdf】，其中第6.3.5.5节有规定使用哪一种卷积编码器。（标准已经规定好了）

2、这个其实就是（2,1,7）卷积码，k0 = 1，n0 = 2，N = 7，该码的生成多项式为（171,133）。

为什么是171（8进制）？

 171（8进制） = 1111001（2进制）

其中输出数据B，分别是 0,1,2,3,6条线有效，多项式写法为 S=x^6 + x^3 +x^2+x^1+x^0(也就是1)。

按照有效为1，无效为0来说，此S可以表示为 1111001，也就是第0、1、2、3、6位的x有效。

如果还是不太清楚，可以去看看通信原理，M序列的产生以及多项式表达方式。

matlab多码速matlab实现：

%%-----------------------------------------------
%函数：1/2码速卷积编码，输入1比特，输出2比特
%%-----------------------------------------------
function CONVOLUTION = Convolution (input_data)
%生成多项式，S(x)=x^6+x^5+x^3+x^2+1;S(x)=x^6+x^3+x^2+x^1+1;
%g0 = [1 0 1 1 0 1 1];
%g1 = [1 1 1 1 0 0 1];
g0 = [0 0 0 0 0 0];
g1 = [0 0 0 0 0 0];
DataNum = length(input_data);
%分别对输入数据进行卷积后模二运算；
j=1;
%1/2码率输出，输出形式为A0B0A1B1A2B2......
for i=1:1:DataNum
    %OutA = mod((conv(input_data(1,i),g0)),2);
    %OutB = mod((conv(input_data(1,i),g1)),2);
    OutA = xor(g0(1,1),g0(1,2));
    OutA = xor(OutA,g0(1,4));
    OutA = xor(OutA,g0(1,5));
    OutA = xor(OutA,input_data(1,i));
    OutB = xor(g1(1,1),g1(1,4));
    OutB = xor(OutB,g1(1,5));
    OutB = xor(OutB,g1(1,6));
    OutB = xor(OutB,input_data(1,i));
    NewData2(1,j) = OutA;
    NewData2(1,j+1) = OutB;
    j=j+2;
    g0=circshift(g0,[0,-1]);
    g1=circshift(g1,[0,-1]);
    g0(1,6)=input_data(1,i);
    g1(1,6)=input_data(1,i);
end
CONVOLUTION = NewData2;
%%-----------------------------------------------
%删余函数
function [punc_patt, punc_patt_size] = get_punc_params(code_rate)
% 打孔参数
if strcmp(code_rate,'R3/4')         % 六个删除两个，由1/2得到3/4
   % R=3/4, Puncture pattern: [1 2 3 x x 6], x = punctured 
   punc_patt=[1 2 3 6];
   punc_patt_size = 6;
elseif strcmp(code_rate, 'R2/3')    % 四个删除一个，由1/2得到2/3
   % R=2/3, Puncture pattern: [1 2 3 x], x = punctured 
   punc_patt=[1 2 3]; 
   punc_patt_size = 4;
elseif strcmp(code_rate, 'R1/2')    % 标准编码器码流，不必打孔
   % R=1/2, Puncture pattern: [1 2 3 4 5 6], x = punctured 
   punc_patt=[1 2 3 4 5 6];
   punc_patt_size = 6;
else
   error('Undefined convolutional code rate');
end
%%------------------------------------------------
%发送模块编码主函数，1/2码率编码，3/4码率删余
function punctured_bits = tx_puncture(input_data, code_rate)
% 打孔，调整传输速率
 [ CONVOLUTION ]= Convolution (input_data)
[punc_patt, punc_patt_size] = get_punc_params(code_rate);

% Remainder bits are the bits in the end of the packet that are not integer multiple of the puncture window size
num_rem_bits = rem(length(CONVOLUTION), punc_patt_size);

puncture_table = reshape(CONVOLUTION(1:length(CONVOLUTION)-num_rem_bits), punc_patt_size, fix(length(CONVOLUTION)/punc_patt_size));
tx_table = puncture_table(punc_patt,:); % 只取不被打孔的行

% puncture the remainder bits
rem_bits = CONVOLUTION(length(CONVOLUTION)-num_rem_bits+1:length(CONVOLUTION));
rem_punc_patt = find(punc_patt<=num_rem_bits);
rem_punc_bits = rem_bits(rem_punc_patt)';

punctured_bits = [tx_table(:)' rem_punc_bits];
%%-----------------------------------------------

输入：001001

1/2码速：000011011100

3/4码速：00010110 

卷积编码模块代码：

module conv_encoder(clk,aclr,data_in,nd,data_out_v,rdy);

input aclr;
input clk;
input data_in;
input nd;
output [1:0] data_out_v;
output rdy;

reg [6:1] shift_reg;
reg [1:0] data_out_v;
reg rdy;

always @ ( negedge aclr or posedge clk )
  begin 
    if ( ! aclr )
	   begin
		  shift_reg <= 6'b000000;
		  data_out_v <= 0;
		  rdy <= 0 ;
		end

    else 
	   if ( nd )
		  begin
		    data_out_v[0] <= shift_reg[6] + shift_reg[5] + shift_reg[3] + shift_reg[2] + data_in;
			 data_out_v[1] <= shift_reg[6] + shift_reg[3] + shift_reg[2] + shift_reg[1] + data_in;
			 rdy<=1;
			 shift_reg <= { shift_reg [5:1], data_in };
		  end
		else
		  rdy <= 0;

  end



endmodule

 2.‘3/4’码率卷积的实现

（1）1/2卷积码放入缓存

（2）删余

（3）输出

module DATA_conv_encoder(DCONV_DIN,DCONV_ND,RATE_CON,DCONV_RST,DCONV_CLK_I,DCONV_CLK_O,DCONV_DOUT,DCONV_INDEX,DCONV_RDY);
    input DCONV_DIN;
    input DCONV_ND;
    input [3:0] RATE_CON;
    input DCONV_RST;
    input DCONV_CLK_I;
    input DCONV_CLK_O;
    output DCONV_DOUT;
    output [8:0] DCONV_INDEX;
    output DCONV_RDY;

	 wire RST;  
	 wire [1:0] DATA_OUT_V;
	 wire RDY;
	 reg BUF_RDY;
	 reg [1:0] i;
	 reg [2:0] j;
	 reg [1:0] Puncture_BUF_12;
	 reg [5:0] Puncture_BUF_34;
	 reg [3:0] Puncture_BUF_23;
	 reg [9:0] INDEX_TEMP;
	 reg DCONV_DOUT;
	 reg [8:0] DCONV_INDEX;
	 reg DCONV_RDY;

	 //assign RST = ~DCONV_RST;

	 conv_encoder conv_encoder1(
	             .data_in(DCONV_DIN),
				 .nd(DCONV_ND),
				 .clk(DCONV_CLK_I),
				 .aclr(DCONV_RST),
				 .data_out_v(DATA_OUT_V),
				 .rdy(RDY));	 

    always @ ( negedge DCONV_RST or posedge DCONV_CLK_I )	  // Put data into puncture_buffer.
	    begin
		    if ( ! DCONV_RST )
			    begin
				    Puncture_BUF_12 <= 0;//1/2速率＿
				 	Puncture_BUF_34 <= 0;//3/4速率＿
					Puncture_BUF_23 <= 0;//2/3速率＿
					i <= 0;
             end

          else
				 begin
				  if ( RDY )
					case ( RATE_CON )
					  4'b1101,4'b0101,4'b1001:		// Rate is 1/2 .
					     begin
						    Puncture_BUF_12 <= DATA_OUT_V;
							BUF_RDY <= 1;
						  end

					  4'b1111,4'b0111,4'b1011,4'b0011:	 // Rate is 3/4 .
					     begin
						     case (i)
							    2'b00:
								    begin
										Puncture_BUF_34 [1:0] <= DATA_OUT_V;
										BUF_RDY <= 1;
										i <= i + 1 ;
									 end
								 2'b01:
									 begin
										Puncture_BUF_34 [3:2] <= DATA_OUT_V;
										BUF_RDY <= 1;
										i <= i + 1 ;
									 end
								 2'b10: 
									 begin
										Puncture_BUF_34 [5:4] <= DATA_OUT_V;
										BUF_RDY <= 1;
										i <= 2'b00 ;
									 end
								 default: 
									 begin
										Puncture_BUF_34 <= 0;
										BUF_RDY <= 0;	 
										i <= 0;
									 end
							       endcase
                    end 

					  4'b0001:		 // Rate is 2/3 .
					     begin
						     case ( i )
							    2'b00:
								   begin
									  Puncture_BUF_23 [1:0] <= DATA_OUT_V;
									  BUF_RDY <= 1;
									  i <= i + 1 ;		    
									end
                         2'b01:
								   begin
									  Puncture_BUF_23 [3:2] <= DATA_OUT_V;
									  BUF_RDY <= 1;
									  i <= 0 ;		    
									end
								 default:
								   begin
									  Puncture_BUF_23 <= 0;
									  BUF_RDY <= 0;
									  i <= 0 ;		    
									end
                       endcase
                    end				   
					endcase
            else
				  begin
					 BUF_RDY <= 0;
					 Puncture_BUF_12 <= 0;
				 	 Puncture_BUF_34 <= 0;
					 Puncture_BUF_23 <= 0;
					 i <= 0;
              end
				end					   
      end		  

   always @ ( negedge DCONV_RST or posedge DCONV_CLK_O ) 	// Puncture and output the data.
	   begin
		  if ( ! DCONV_RST )
		    begin
			   DCONV_DOUT <= 0 ;
				DCONV_RDY <= 0;
				j <= 3'b000;
			 end
			 
		  else  
		    if ( BUF_RDY ) 
			   case ( RATE_CON )
					  4'b1101,4'b0101,4'b1001:		// Rate is 1/2 .
					     begin
						    case ( j )
							   3'b000:
								   begin
								     DCONV_DOUT <= Puncture_BUF_12 [j] ;
									  DCONV_RDY <= 1;
									  j <= j +1 ;
									end
                                3'b001:
								   begin
								     DCONV_DOUT <= Puncture_BUF_12 [j] ;
									  DCONV_RDY <= 1;
									  j <= 3'b000 ;
									end
                              default:
								   begin
									  DCONV_DOUT <= 0 ;
									  DCONV_RDY <= 0;
									  j <= 3'b000 ;
                           end
							 endcase
 						  end

					  4'b1111,4'b0111,4'b1011,4'b0011:	 // Rate is 3/4 .
					     begin
						     case (j)
							    3'b000,3'b001,3'b010:
								    begin
										DCONV_DOUT <= Puncture_BUF_34 [j] ;
									   DCONV_RDY <= 1;
									   j <= j + 1 ;
									 end 
								 3'b011: 
									 begin
										DCONV_DOUT <= Puncture_BUF_34 [j+2] ;
									   DCONV_RDY <= 1;
									   j <= 3'b000 ;
									 end
								 default: 
									 begin
										DCONV_DOUT <= 0;
										DCONV_RDY <= 0;	 
										j <= 0;
									 end
							       endcase
                    end 

					  4'b0001:		 // Rate is 2/3 .
					     begin
						     case ( j )
							    3'b000,3'b001:
								   begin
									  DCONV_DOUT <= Puncture_BUF_23 [j] ;
									  DCONV_RDY <= 1;
									  j <= j + 1 ;		    
									end
                         3'b010:
								   begin
									  DCONV_DOUT <= Puncture_BUF_23 [j] ;
									  DCONV_RDY <= 1;
									  j <= 3'b000 ;		    
									end
								 default:
								   begin
									  DCONV_DOUT <= 0 ;
									  DCONV_RDY <= 0 ;
									  j <= 0 ;		    
									end
                       endcase 
						  end
						   default:
                                                 begin
                                                 
                                                     DCONV_INDEX <= 0 ;   
                                                 end
				endcase

         else
			  begin
			    DCONV_DOUT <= 0 ;
				 DCONV_RDY <= 0 ;
           end
		end			 

    always @ ( negedge DCONV_RST or posedge DCONV_CLK_O )  	 // Index output.
	    begin  
		   if ( ! DCONV_RST )
		      begin
			     DCONV_INDEX <= 0 ;
				  INDEX_TEMP <= 0;
			   end

			else
			 begin
			  if ( BUF_RDY )
			     case ( RATE_CON )
				    4'b1101,4'b1111:
					    begin
						   if( INDEX_TEMP < 47 )
							  begin
							    INDEX_TEMP <= INDEX_TEMP + 1 ;
                         DCONV_INDEX <= INDEX_TEMP ;
							  end
							else
							  begin
							    INDEX_TEMP <= 0 ;
                         DCONV_INDEX <= INDEX_TEMP ; 
							  end
                   end
				    4'b0101,4'b0111:                
						 begin
						   if( INDEX_TEMP < 95 )
							  begin
							    INDEX_TEMP <= INDEX_TEMP + 1 ;
                         DCONV_INDEX <= INDEX_TEMP ;
							  end
							else
							  begin
							    INDEX_TEMP <= 0 ;
                         DCONV_INDEX <= INDEX_TEMP ; 
							  end
                   end
				    4'b1001,4'b1011:                
						 begin
						   if( INDEX_TEMP < 191 )
							  begin
							    INDEX_TEMP <= INDEX_TEMP + 1 ;
                         DCONV_INDEX <= INDEX_TEMP ;
							  end
							else
							  begin
							    INDEX_TEMP <= 0 ;
                         DCONV_INDEX <= INDEX_TEMP ; 
							  end
                   end                
				    4'b0001,4'b0011:                
						 begin
						   if( INDEX_TEMP < 287 )
							  begin
							    INDEX_TEMP <= INDEX_TEMP + 1 ;
                         DCONV_INDEX <= INDEX_TEMP ;
							  end
							else
							  begin
							    INDEX_TEMP <= 0 ;
                         DCONV_INDEX <= INDEX_TEMP ; 
							  end
                   end
				  endcase
			  else
			    DCONV_INDEX <= 0 ;
          end
		 end						  


endmodule

 

 代码：

module DATA_conv_encoder(DCONV_DIN,DCONV_ND,RATE_CON,DCONV_RST,DCONV_CLK_I,
                            DCONV_CLK_O,DCONV_DOUT,DCONV_INDEX,DCONV_RDY);
    input DCONV_DIN;
    input DCONV_ND;
    input [3:0] RATE_CON;
    input DCONV_RST;
    input DCONV_CLK_I;
    input DCONV_CLK_O;
    output DCONV_DOUT;
    output [8:0] DCONV_INDEX;
    output DCONV_RDY;

	 wire RST;  
	 wire [1:0] DATA_OUT_V;
	 wire RDY;
	 reg BUF_RDY;
	 reg [1:0] i;
	 reg [2:0] j;
	 reg [1:0] Puncture_BUF_12;
	 reg [5:0] Puncture_BUF_34;
	 reg [3:0] Puncture_BUF_23;
	 reg [9:0] INDEX_TEMP;
	 reg DCONV_DOUT;
	 reg [8:0] DCONV_INDEX;
	 reg DCONV_RDY;

	 //assign RST = ~DCONV_RST;

	 conv_encoder conv_encoder1(
	             .data_in(DCONV_DIN),
				 .nd(DCONV_ND),
				 .clk(DCONV_CLK_I),
				 .aclr(DCONV_RST),
				 .data_out_v(DATA_OUT_V),
				 .rdy(RDY));	 

    always @ ( negedge DCONV_RST or posedge DCONV_CLK_I )	  // Put data into puncture_buffer.
	    begin
		    if ( ! DCONV_RST )
			    begin
				   Puncture_BUF_12 <= 0;
				 	Puncture_BUF_34 <= 0;
					Puncture_BUF_23 <= 0;
					i <= 0;
             end

          else
				 begin
				  if ( RDY )
					case ( RATE_CON )
					  4'b1101,4'b0101,4'b1001:		// Rate is 1/2 .
					     begin
						    Puncture_BUF_12 <= DATA_OUT_V;
							 BUF_RDY <= 1;
						  end

					  4'b1111,4'b0111,4'b1011,4'b0011:	 // Rate is 3/4 .
					     begin
						     case (i)
							    2'b00:
								    begin
										Puncture_BUF_34 [1:0] <= DATA_OUT_V;
										BUF_RDY <= 1;
										i <= i + 1 ;
									 end
								 2'b01:
									 begin
										Puncture_BUF_34 [3:2] <= DATA_OUT_V;
										BUF_RDY <= 1;
										i <= i + 1 ;
									 end
								 2'b10: 
									 begin
										Puncture_BUF_34 [5:4] <= DATA_OUT_V;
										BUF_RDY <= 1;
										i <= 2'b00 ;
									 end
								 default: 
									 begin
										Puncture_BUF_34 <= 0;
										BUF_RDY <= 0;	 
										i <= 0;
									 end
							       endcase
                    end 

					  4'b0001:		 // Rate is 2/3 .
					     begin
						     case ( i )
							    2'b00:
								   begin
									  Puncture_BUF_23 [1:0] <= DATA_OUT_V;
									  BUF_RDY <= 1;
									  i <= i + 1 ;		    
									end
                         2'b01:
								   begin
									  Puncture_BUF_23 [3:2] <= DATA_OUT_V;
									  BUF_RDY <= 1;
									  i <= 0 ;		    
									end
								 default:
								   begin
									  Puncture_BUF_23 <= 0;
									  BUF_RDY <= 0;
									  i <= 0 ;		    
									end
                       endcase
                    end				   
					endcase
            else
				  begin
					 BUF_RDY <= 0;
					 Puncture_BUF_12 <= 0;
				 	 Puncture_BUF_34 <= 0;
					 Puncture_BUF_23 <= 0;
					 i <= 0;
              end
				end					   
      end		  

   always @ ( negedge DCONV_RST or posedge DCONV_CLK_O ) 	// Puncture and output the data.
	   begin
		  if ( ! DCONV_RST )
		    begin
			   DCONV_DOUT <= 0 ;
				DCONV_RDY <= 0;
				j <= 3'b000;
			 end
			 
		  else  
		    if ( BUF_RDY ) 
			   case ( RATE_CON )
					  4'b1101,4'b0101,4'b1001:		// Rate is 1/2 .
					     begin
						    case ( j )
							   3'b000:
								   begin
								     DCONV_DOUT <= Puncture_BUF_12 [j] ;
									  DCONV_RDY <= 1;
									  j <= j +1 ;
									end
                        3'b001:
								   begin
								     DCONV_DOUT <= Puncture_BUF_12 [j] ;
									  DCONV_RDY <= 1;
									  j <= 3'b000 ;
									end
                        default:
								   begin
									  DCONV_DOUT <= 0 ;
									  DCONV_RDY <= 0;
									  j <= 3'b000 ;
                           end
							 endcase
 						  end

					  4'b1111,4'b0111,4'b1011,4'b0011:	 // Rate is 3/4 .
					     begin
						     case (j)
							    3'b000,3'b001,3'b010:
								    begin
										DCONV_DOUT <= Puncture_BUF_34 [j] ;
									   DCONV_RDY <= 1;
									   j <= j + 1 ;
									 end 
								 3'b011: 
									 begin
										DCONV_DOUT <= Puncture_BUF_34 [j+2] ;
									   DCONV_RDY <= 1;
									   j <= 3'b000 ;
									 end
								 default: 
									 begin
										DCONV_DOUT <= 0;
										DCONV_RDY <= 0;	 
										j <= 0;
									 end
							       endcase
                    end 

					  4'b0001:		 // Rate is 2/3 .
					     begin
						     case ( j )
							    3'b000,3'b001:
								   begin
									  DCONV_DOUT <= Puncture_BUF_23 [j] ;
									  DCONV_RDY <= 1;
									  j <= j + 1 ;		    
									end
                         3'b010:
								   begin
									  DCONV_DOUT <= Puncture_BUF_23 [j] ;
									  DCONV_RDY <= 1;
									  j <= 3'b000 ;		    
									end
								 default:
								   begin
									  DCONV_DOUT <= 0 ;
									  DCONV_RDY <= 0 ;
									  j <= 0 ;		    
									end
                       endcase 
						  end
				endcase

         else
			  begin
			    DCONV_DOUT <= 0 ;
				 DCONV_RDY <= 0 ;
           end
		end			 

    always @ ( negedge DCONV_RST or posedge DCONV_CLK_O )  	 // Index output.
	    begin  
		   if ( ! DCONV_RST )
		      begin
			     DCONV_INDEX <= 0 ;
				  INDEX_TEMP <= 0;
			   end

			else
			 begin
			  if ( BUF_RDY )
			     case ( RATE_CON )
				    4'b1101,4'b1111:
					    begin
						   if( INDEX_TEMP < 47 )
							  begin
							    INDEX_TEMP <= INDEX_TEMP + 1 ;
                         DCONV_INDEX <= INDEX_TEMP ;
							  end
							else
							  begin
							    INDEX_TEMP <= 0 ;
                         DCONV_INDEX <= INDEX_TEMP ; 
							  end
                   end
				    4'b0101,4'b0111:                
						 begin
						   if( INDEX_TEMP < 95 )
							  begin
							    INDEX_TEMP <= INDEX_TEMP + 1 ;
                         DCONV_INDEX <= INDEX_TEMP ;
							  end
							else
							  begin
							    INDEX_TEMP <= 0 ;
                         DCONV_INDEX <= INDEX_TEMP ; 
							  end
                   end
				    4'b1001,4'b1011:                
						 begin
						   if( INDEX_TEMP < 191 )
							  begin
							    INDEX_TEMP <= INDEX_TEMP + 1 ;
                         DCONV_INDEX <= INDEX_TEMP ;
							  end
							else
							  begin
							    INDEX_TEMP <= 0 ;
                         DCONV_INDEX <= INDEX_TEMP ; 
							  end
                   end                
				    4'b0001,4'b0011:                
						 begin
						   if( INDEX_TEMP < 287 )
							  begin
							    INDEX_TEMP <= INDEX_TEMP + 1 ;
                         DCONV_INDEX <= INDEX_TEMP ;
							  end
							else
							  begin
							    INDEX_TEMP <= 0 ;
                         DCONV_INDEX <= INDEX_TEMP ; 
							  end
                   end
				  endcase
			  else
			    DCONV_INDEX <= 0 ;
          end
		 end						  


endmodule

注意问题：1、matlab中数据的方向

                 2、fpga中数据的方向 

 

xl@666
关注
专栏目录
BPSK调制下(2,1,6)标准卷积码及打孔生成2/3、3/4、4/5、5/6删余码Viterbi译码误码率曲线图(MATLAB实现)
业精于勤，荒于嬉
09-19 4272
目录仿真结果卷积码原理图删余后性能比较常用的删余码仿真代码根据码率生成打孔参数(子函数)将标准(2, 1, 6)编码后的序列进行打孔，生成删余码(子函数)对接收到的序列进行反打孔，将原来打孔删除的比特进行补零(子函数)BPSK调制下(2,1,6)标准卷积码及打孔生成2/3、3/4、4/5、5/6删余码Viterbi译码误码率曲线图获取更多内容请关注(暂未运营，后续有时间了会分享更多内容)： 仿真结果 卷积码原理图 打孔生成删余码的具体实现部分有详细的注释，一看必会！ 删余后性能比较 由上图可见，当我们
图像处理：卷积模块FPGA 硬件加速
weixin_34248118的博客
04-22 1321
本文记录了利用FPGA加速图像处理中的卷积计算的设计与实现。实现环境为Altera公司的Cyclone IV型芯片，NIOS II软核+FPGA架构。 由于这是第一次设计硬件加速模块，设计中的瑕疵以及问题欢迎前来讨论。 更新记录： D0423 记录FPGA核心计算模块和控制模块 D0426 记录FPGA核心计算模块的控制驱动，性能与功能测试 Part1 : 卷积相...
卷积神经网络硬件实现综述：A Survey of Convolutional Neural Networks on Edge with Reconfigurable Computing
小陈的芯片学习之路
01-28 2035
卷积神经网络硬件实现综述阅读
卷积的实现
burning1996的博客
10-12 494
卷积函数的定义 import numpy as np from PIL import Image import matplotlib.pyplot as plt import matplotlib.cm as cm ''' image_array: 原灰度图像矩阵 kernel: 卷积核（过滤器） 返回值：原图像与算子进行卷积之后的结果 ''' def ImgConvolve(image_ar...
卷积层硬件实现和优化方法——卜居.pdf
12-01
CNN中的卷积层 直接实现方法 Caffe实现方法 FFT实现方法 CUDNN实现方法 FPGA硬件实现 优化策略
推荐硬件实现的卷积神经网络：Hardware-CNN
最新发布
gitblog_00045的博客
06-14 401
推荐硬件实现的卷积神经网络：Hardware-CNN Hardware-CNNA convolutional neural network implemented in hardware (verilog)项目地址:https://gitcode.com/gh_mirrors/ha/Hardware-CNN 在这个数字时代，人工智能和深度学习正在引领技术创新的浪潮。特别是卷积神经网络（CNN），...
lftp4.4.8离线安装包
06-15
3. trousers-0.3.14-2.el7.x86_64.rpm：Trousers项目提供了一个开源的TPM（Trusted Platform Module）接口，主要用于实现安全启动和硬件加密等功能。虽然lftp本身并不直接使用TPM，但在某些特定环境中，TPM支持可能...
Asp微信支付接口代码 v4.4.8
09-30
众所周到，目前微信支付已经十分普及，无论是商场、超市、网站上，微信支付的发展十分迅速，而ASP版微信支付在微信公众平台上并没有提供，而目前基于ASP语言开发的网站又十分普
4.4.8- Troubleshoot Inter-VLAN Routing
05-27
4.4.8 Packet Tracer - Troubleshoot Inter-VLAN Routing Cisco Packet Tracer 思科模拟器 正确答案文件 可直接上交正确答案文件 本答案版权归mewhaku所有，严禁再次转载！！！ Copyright @mewhaku 2022 All ...
swoole-4.4.8.tgz
04-13
而`swoole-4.4.8`目录则包含了该版本的源代码，我们可以在此基础上进行编译安装或进一步研究Swoole的内部实现。 使用Swoole时，开发者可以创建Server对象，定义监听的端口和处理网络请求的回调函数。例如，你可以...
基于FPGA的卷积码 的编码实现的 源代码
04-25
基于 FPGA实现 卷积码的 编码过程 经典的实现过程 占用最小的逻辑资源
MK Glow 4.4.8
03-12
"MK Glow 4.4.8" 是一个针对Unity游戏引擎的专业特效插件，它专为开发者设计，用于提升游戏视觉效果，特别是光效部分。这个版本4.4.8代表了该插件的更新迭代，通常伴随着性能优化、新功能的添加或已有功能的改进。 ...
从零开始：使用Verilog硬件描述语言实现卷积神经网络的详细指南
qq_38334677的博客
09-22 1135
最后，我们将所有的模块整合到一个完整的CNN中。全连接层是神经网络的最后一层，它将前面的所有输出连接到一个或多个神经元，用于分类或其他任务。在这里，我们将实现一个简单的全连接层，它只有一个输出神经元，用于二分类。简单来说，CNN是一种特殊的神经网络结构，它特别适合处理具有网格结构的数据，如图像。与传统的编程语言不同，Verilog描述的是硬件的结构和行为，而不是按顺序执行的指令序列。需要注意的是，这只是一个简化的例子，真实的CNN可能会更加复杂。：为了简洁和清晰，本文中的代码可能不是最优的或最完整的实现。
数字IC实践项目（3）——卷积神经网络加速器（开源项目）
HFUT90S的博客
04-12 5319
该项目是一个简单的卷积神经网络硬件化实现， 没有构建对应的神经网络算法，也并没有完成下板综合测试；其中，卷积和池化模块的构建方法可以用来实现具体的神经网络架构。项目实践环境：FPGA开发环境：前仿： Modelsim SE-64 2019.2综合： Quartus (Quartus Prime 17.1) Standard Edition数字IC开发环境：前仿： VCS 2016综合：DC 2016
数字信号处理的fpga实现_数字信号处理的卷积运算实现
weixin_39897127的博客
11-23 444
一、卷积的定义在数字信号处理中，当一个系统是线性时不变系统时，引出了卷积；卷积是线性和时不变性的一个直接结果。卷积的公式为： 即如果已知所有的x[n]和h[n]就可由卷积公式求出输出序列y[n]。二、卷积的计算在使用该公式进行计算时，由h[k]求出h[n-k]需要分两步进行：首先，将h[k]关于k=0反转；然后，将反转后的信号延迟n个样本。例：考虑一个系统，单位脉冲响应为 ，输入是 ,求出y[...
Vitis HLS 学习笔记--硬件卷积加速 Filter2DKernel
hi94的博客
04-12 1152
就表示没有数据相关性，那么编译器就可以在同一个循环内自由地移动读写操作的位置，从而提高操作的可调度性和潜在的性能或面积优化。，就表示没有数据相关性，那么编译器就可以在流水线化或展开循环时并行执行多个循环的读写操作，从而提高吞吐量。，就表示有数据相关性，那么编译器就会保证每一次循环内的读写操作都按照顺序执行，不能移动位置。，就表示有数据相关性，那么编译器就会保证每一次循环的读写操作都按照顺序执行，不能并行化。工具计算循环的延迟，从而在报告中显示循环对总设计延迟的贡献，并帮助确定适合的优化方法。
FPGA实现OFDM（三）- 多码率卷积码的FPGA实现
今日你学左米啊
10-21 2422
FPGA实现OFDM（三）- FEC编码器/多码率卷积码的FPGA实现 研究生 生活 下 fpga_blog->(1) : 最近做课题相关的太多了,跳出一下 上一篇: FPGA实现OFDM(1)-OFDM原理 FPGA实现OFDM（二）-整体系统框架 在上一篇中我们已经建模完整体的OFDM的R/T过程,这里我们开始从这个图开始,从发射机开始到接收机,一个个模块实现: 会和书中实现的顺序不一样.讲的代码也会有点不一样 文章目录FPGA实现OFDM（三）- FEC编码器/多码率卷积码的FPGA实现F
Verilog搭建神经网络学习记录，Day4：单次卷积操作实现
u012915630的博客
07-23 601
单次卷积操作，就是简单地把图片与卷积核的对应位置的元素相乘，然后再求和。如下图所示。
React Redux 4.4.8官方绑定高性能与灵活性介绍
资源摘要信息:"react-redux-4.4.8.zip" 在深入探讨react-redux-4.4.8.zip文件之前，有必要先了解相关的核心技术概念。react-redux是React的一个官方库，用于将Redux状态管理库与React集成。Redux是JavaScript应用中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值