【【硬件数据流从control to FIFO1 to adder to RAM to FIFO2 to control2的 verilog 代码实现 ---- 初版 】】

最新推荐文章于 2024-09-07 21:45:34 发布
最新推荐文章于 2024-09-07 21:45:34 发布
阅读量54 收藏
点赞数
分类专栏： FPGA学习 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50965981/article/details/134205235
版权

硬件数据流从control to FIFO1 to adder to RAM to FIFO2 to control2的 verilog 代码实现 ---- 初版

这是初版的代码 可以提供 一个大概的思路
如果想要处理大数据的话 把 BRAM需要修改 我先做了一个简单的环路 将 地址始终 固定为1
还有 里面内部的各种使能信号 我尽可能 的 完成贴近 握手协议 但是 对于只 传递 一个数据位
并不需要考虑太多此处的问题
我们只展示初步的代码

adder.v

module adder #(
    parameter       NUMBER1      =      8                ,
    parameter       NUMBER2      =      8
  )(
    input  [NUMBER1-1 : 0]                  input1       ,
    input  [NUMBER2-1 : 0]                  input2       ,
    input                                   clk          ,
    input                                   rst_n        ,
    input                                   begin_en     ,
    output  reg                             finish_en    ,
    output  reg [NUMBER1-1 : 0]       out
  );


  //======================================================================================\
  //                define parameter  and  internal signal                                \
  //======================================================================================\
  reg [1:0] LCD = 2'b10 ;
  reg [1:0] LCD1 ;

  //==========================================================================================\
  //                     next   is  main  code                                                 \\
  //===========================================================================================\\

  always@(posedge clk or negedge rst_n)
  begin

    if(rst_n == 0)
    begin
      out <= 0 ;
    end

    else
      LCD1 <= LCD  ;
  end



  always@(posedge clk or negedge rst_n)
  begin
    if(rst_n == 0)
    begin
      out <= 0 ;
    end
    else  if(begin_en && finish_en )
    begin

      out <= input1 + input2 ;
      LCD <= {LCD[0],LCD[1]} ;
    end
    else
      out <= out ;
  end



  always@(posedge clk or negedge rst_n)
  begin
    if(rst_n == 0)
    begin
      finish_en <= 1'b1 ;
    end
    else if(LCD == LCD1)
    begin
      finish_en <= 1'b1 ;
    end
    else
      finish_en <= 1'b0 ;
  end


endmodule

control.v

module control #(
    parameter               WIDTH      =      8                  
    //parameter               TKEEP      =      clogb2(WIDTH)
  )(
    input                      sys_clk        ,
    input                      sys_rst_n      ,
   // input      [TKEEP-1 : 0]   s_keep         ,
    input                      tvaild         ,
    input      [WIDTH-1 : 0]   din            ,
    output  reg                   tready         ,
    output  reg   [WIDTH-1 : 0]   dout           ,
    output  reg                   wr_en          ,
    output  reg                   rd_en
  );
  //=============================================================================\\
  //        define  parameter  and internal  signals                             \\
  //==============================================================================\\
  reg [1:0] LCD = 2'b10 ;
  reg [1:0] LCD1  ;


  //===============================================================================\\
  //                         next is  main code                                    \\
  //================================================================================\\


  //this is function
  function integer clogb2 ;
    input [31:0] value ;
    begin
      value = value - 1 ;
      for(clogb2=0;value>0;clogb2=clogb2+1)
        value = value >> 1 ;
    end
  endfunction


  //this is build to control for handshake
  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      LCD1 <= 0 ;
    end
    else
      LCD1 <= LCD ;
  end


  // this is for  output
  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      dout <= 0;
    end
    else if( tvaild  && tready )
    begin
      dout <= din ;
      LCD <= {LCD[0],LCD[1]}  ;
    end
    else
    begin
      dout <= dout ;
    end
  end

  // this is used to build tready
  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      tready <= 1'b1 ;
    end
    else if(LCD == LCD1)
    begin
      tready <= 1'b1 ;
    end
    else
      tready<= 1'b0 ;
  end

  //this is used to wr_en   or  rd_en
  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      wr_en <= 0 ;
      //rd_en <= 0 ;
    end
    else
    begin
      wr_en<= (tready == 1) ? 1 : 0 ;
     // rd_en <= 1 ;
    end
  end

// i want to build a way let if write that we read 
//this is used to rd_en 
  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      rd_en <= 0 ;
    end
    else
    begin
      rd_en <= (wr_en == 1) ? 1 : 0  ;
    end
  end
endmodule

control2.v

module control2 #(
    parameter              WIDTH      =      8
    // parameter              KEPBIT     =      count(WIDTH)
  )(
    input                          sys_clk         ,
    input                          sys_rst_n       ,
    input                          tready1         ,     //  this control2 is used to get from DMA read
    input      [WIDTH-1 : 0]       din             ,
    // next is output four output

    output  reg                       s_tvaild       ,
    output  reg   [WIDTH-1 : 0]       s_dout         ,
    output  reg                        s_last
    //output  reg                    s_tlast        ,
    // output  reg   [KEPBIT-1:0]     s_tkeep
  );
  //=============================================================================\\
  //        define  parameter  and internal  signals                             \\
  //==============================================================================\\
  reg [1:0]             LCD = 2'b10 ;
  reg [1:0]             LCD1        ;
  reg [WIDTH-1 : 0]     dout1       ;




  //===============================================================================\\
  //                         next is  main code                                    \\
  //================================================================================\\


  //this is function
  // function integer count ;
  // input [31:0] value ;
  //  begin
  //   for(count=0;value>0;count=count+1)
  //      value = value >> 8 ;
  //  end
  // endfunction




  //this is build to control for handshake
  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      LCD1 <= 0 ;
    end
    else
      LCD1 <= LCD ;
  end



  // this is for  output  s_dout
  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      s_dout <= 0;
    end
    else if( s_tvaild  && tready1 )
    begin
      s_dout <= din ;
      LCD <= {LCD[0],LCD[1]}  ;
    end
    else
    begin
      s_dout <= s_dout ;
    end
  end


  // this is used to build s_tvaild
  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      s_tvaild <= 1'b1 ;
    end
    else if(LCD == LCD1)
    begin
      s_tvaild <= 1'b1 ;
    end
    else
      s_tvaild<= 1'b0 ;
  end


  // this is what we add to give out

  always@(posedge sys_clk  or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      s_last <= 0 ;
    end
    else if(s_dout == dout1 )
    begin
      s_last <= 1 ;
    end
    else
      s_last <= 0 ;

  end

  // this is what we add to give last
  always@(posedge sys_clk  or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      dout1 <= 0 ;
    end
    else
      dout1 <= s_dout ;
  end



endmodule

FIFO1.v

//synchronous  fifo
module FIFO_syn #(
    parameter 		WIDTH		=	16,                    //  the fifo wide
    parameter 		DEPTH		=	1024,                  //  deepth
    parameter 		ADDR_WIDTH	=	clogb2(DEPTH)        //  bit wide
 //   parameter 		PROG_EMPTY	=	100,                   //  this what we set to empty
  //  parameter 		PROG_FULL	=	800                     //  this what we set to full
  )
  (
    input   sys_clk                    ,
    input   sys_rst_n                    ,
    input   wr_en                      ,
    input   rd_en                      ,
    input   [WIDTH-1: 0] din           ,
    output  reg  full                  ,
    output  reg  empty                 ,         ///  1 is  real empty  0 is no empty
    output  reg  [WIDTH-1:0]  dout     
  );

  //========================================================================================//
  //                              define parameter and internal signals                     //
  //======================================================================================//
  reg [WIDTH-1 : 0]          ram[DEPTH-1 : 0]   ;     // this we set a  15:0   total 1024 number ram
  reg [ADDR_WIDTH-1 : 0]     wr_addr            ;     // this is  write pointer
  reg [ADDR_WIDTH-1 : 0]     rd_addr            ;     // this is  read  pointer
  reg [ADDR_WIDTH-1 : 0]     fifo_cnt           ;

  //=========================================================================================//
  //                             next  is  main code                                           //
  //=========================================================================================//

  //  we  set a function  let me to  count    the number
  function integer clogb2;                     //  remember integer has  symbol  reg  has no symbol
    input[31:0]value;
    begin
      value=value-1;
      for(clogb2=0;value>0;clogb2=clogb2+1)
        value=value>>1;
    end
  endfunction
  //   this  you can see from the  PPT 5-74


  //===================================================  next  is used to read

  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
      rd_addr		<=		{ADDR_WIDTH{1'b0}};
    else if(rd_en && !empty)
    begin
      rd_addr		<=		rd_addr+1'd1;
      dout		<=		ram[rd_addr];
    end
    else
    begin
      rd_addr		<=		rd_addr;
      dout		<=		dout;
    end
  end




  //===================================================  next  is used to write
  always@(posedge sys_clk  or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      wr_addr         <=    {ADDR_WIDTH{1'b0}}   ;         //  this  let pointer to zero
    end
    else if( wr_en  &&  !full )
    begin   // no full and  wr_en   and  whether to write prog_full there
      wr_addr          <=    wr_addr + 1'b1  ;
      ram[wr_addr]     <=    din             ;
    end
    else
      wr_addr          <=    wr_addr         ;
  end





  //==============================================================  next  is  used to set fifo_cnt
  always@(posedge sys_clk  or negedge sys_rst_n )
  begin
    if(sys_rst_n == 0)
    begin
      fifo_cnt  <=  {ADDR_WIDTH{1'b0}};
    end
    else if(wr_en &&  !full  &&  !rd_en)
    begin
      fifo_cnt  <=   fifo_cnt + 1'b1 ;
    end
    else if(rd_en && !empty && !wr_en)
    begin
      fifo_cnt  <=  fifo_cnt - 1'b1 ;
    end
    else
      fifo_cnt  <=  fifo_cnt ;
  end


  //==========================================================     next is empty
  //  we set  counter  so  when the count is zero  empty
  always@(posedge sys_clk  or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0)
    begin
      empty <= 1'b1 ;      //  begin  we set empty to high
    end
    // there is  two possibilties first no write fifo_cnt is all zero
    //second is no write it will be change to zero  is just a will empty signal
    else
      empty <=  (!wr_en && (fifo_cnt[ADDR_WIDTH-1:1] == 'b0))&&((fifo_cnt[0] == 1'b0) || rd_en);
  end



  //============================================================  next is full

  always@(posedge sys_clk or negedge sys_rst_n)
  begin
    if(sys_rst_n == 0 )
      full	<=	1'b1;//reset:1
    else
      full	<=	(!rd_en	&&	(fifo_cnt[ADDR_WIDTH-1:1]=={(ADDR_WIDTH-1){1'b1}})) && ((fifo_cnt[0] == 1'b1) || wr_en);
  end

endmodule

RAM.v

//DUal ended RAM 
module RAM #(
    parameter     WIDTH      =     8   ,
    parameter     DEPTH      =     16  ,
    parameter     ADD_WIDTH  =     clogb2(DEPTH) 
)(
    input                       wr_clk         ,
    input                       rd_clk         ,
    input                       wr_en          ,
    input                       rd_en          ,
    input      [WIDTH-1 : 0 ]      din         ,
    input      [ADD_WIDTH-1 : 0]   wr_address  ,
    output reg [WIDTH-1 : 0 ]      dout        ,
    input      [ADD_WIDTH-1 : 0]   rd_address  
);


//==================================================================================\\
//       define  parameter   and  internal   signal                                 \\
//==================================================================================\\

reg [WIDTH - 1 : 0 ] ram [DEPTH - 1 : 0] ; 





//==================================================================================\\
//                              next is  main code                                  \\
//==================================================================================\\


function integer clogb2  ;
input [31:0] value  ;
begin 
    value = value - 1 ;
    for(clogb2 = 0 ; value > 0 ; clogb2 = clogb2 + 1)
    value = value >> 1 ; 
end
endfunction 


// write  
always@(posedge wr_clk) 
begin 
    if(wr_en) begin 
        ram[wr_address] <= din ;
    end
end 

//read 
always@(posedge rd_clk) 
begin 
    if(rd_en) begin 
        dout <= ram[rd_address] ;
    end
end 
endmodule

top.v

module dig_top #(
    parameter            CONTROL1_WIDTH        =         8                      ,
    parameter            FIFO1_WIDTH           =         8                      ,
    parameter            FIFO1_DEPTH           =         1024                   ,
    parameter            FIFO1_ADDR_WIDTH      =         clogb2(FIFO1_DEPTH)    ,
    parameter            NUMBER1               =         8                      ,
    parameter            NUMBER2               =         2                      ,
    parameter            RAM_WIDTH             =         8                      ,
    parameter            RAM_DEPTH             =         8                      ,
    parameter            RAM_ADDR_WIDTH        =         clogb2(RAM_DEPTH)      ,
    parameter            FIFO2_WIDTH           =         8                      ,
    parameter            FIFO2_DEPTH           =         1024                   ,
    parameter            FIFO2_ADDR_WIDTH      =         clogb2(FIFO1_DEPTH)    ,
    parameter            CONTROL2_WIDTH        =         8
  )(
    input                                      sys_clk    ,
    input                                      sys_rst_n  ,
    input                                      tvaild     ,
    output                                     tready     ,
    input     [CONTROL1_WIDTH-1 : 0]           din        ,
    output    [CONTROL2_WIDTH-1 : 0]           dout       ,
    output                                     s_tvaild   ,
    input                                      s_ready    ,
    output                                     s_last      
  );

  //====================================================================================\\
  //                            define  parameter or  internal  signals                 \\
  //====================================================================================\\

  //control1 
  wire                             wr_en         ;
  wire                             rd_en         ;
  wire   [CONTROL1_WIDTH - 1 : 0]  dout_control  ; 
  wire                             full          ;
  wire                             empty         ;
  wire   [FIFO1_WIDTH - 1 : 0]     dout_FIFO     ;
  wire                             finish_en     ;
  wire   [RAM_WIDTH - 1 : 0]       dout_adder    ;
  wire   [RAM_WIDTH - 1 : 0]       dout_RAM      ;
  wire                             RAM_rd_en1    ;
  wire                             RAM_rd_en     ;
  wire                             FIFO2_full    ;
  wire                             FIFO2_empty   ;
  wire   [FIFO2_WIDTH - 1 : 0]     dout_FIFO2    ;











  //========================================================================================\\
  //                       next  is  main code                                              \\
  //=========================================================================================\\
  function integer clogb2 ;
    input [31:0] value ;
    begin
      value = value - 1 ;
      for(clogb2 = 0 ; value > 0 ; clogb2 = clogb2 + 1)
        value = value >> 1 ;
    end
  endfunction

  //next is control1 

control#(
    .WIDTH      ( CONTROL1_WIDTH )
)u_control(
    .sys_clk    ( sys_clk            ),
    .sys_rst_n  ( sys_rst_n          ),
    .tvaild     ( tvaild             ),     // input 
    .din        ( din                ),     // input 
    .tready     ( tready             ),     // output  
    .dout       ( dout_control       ),     //wire
    .wr_en      ( wr_en              ),    //wire   we set just tready == 1 wr_en 
    .rd_en      ( rd_en              )    //wire    we set always in 1 
);

//next is FIFO1
FIFO_syn#(
    .WIDTH      ( FIFO1_WIDTH ),
    .DEPTH      ( FIFO1_DEPTH ),
    .ADDR_WIDTH ( FIFO1_ADDR_WIDTH )
)u_FIFO_syn(
    .sys_clk    ( sys_clk             ),
    .sys_rst_n  ( sys_rst_n           ),
    .wr_en      ( wr_en               ),
    .rd_en      ( rd_en               ),
    .din        ( dout_control        ),     // from control     
    .full       ( full                ),
    .empty      ( empty               ),
    .dout       ( dout_FIFO           )     // this  is  from  FIFO send to adder input1
);

// next is adder
adder#(
    .NUMBER1    ( NUMBER1 ),
    .NUMBER2    ( NUMBER2 )
)u_adder(
    .input1     ( dout_FIFO     ),        // this is from FIFO 
    .input2     ( 2'b10         ),
    .clk        ( sys_clk       ),
    .rst_n      ( sys_rst_n     ),
    .begin_en   ( rd_en         ),         //  this is connect rd_en 
    .finish_en  ( finish_en     ),
    .out        ( dout_adder    )         //  this is send to bram 
);


// there we should add one change the RAM_rd_en  







// something should be add 
// becasuse we just send one number we should not think the module whether address


// next is BRAM  
RAM#(
    .WIDTH       ( RAM_WIDTH      ),
    .DEPTH       ( RAM_DEPTH      ),
    .ADD_WIDTH   ( RAM_ADDR_WIDTH )
)u_RAM(
    .wr_clk      ( sys_clk     ),
    .rd_clk      ( sys_clk     ),
    .wr_en       ( finish_en   ),
    .rd_en       ( 1           ),      //  i think  we should set something   
    .din         ( dout_adder  ),      //  the out is from adder
    .wr_address  ( 1           ),       //    i just set one way so we put address just a set value 
    .dout        ( dout_RAM    ),
    .rd_address  ( 1           )
);


//next is FIFO2  

FIFO_syn#(
    .WIDTH      ( FIFO2_WIDTH ),
    .DEPTH      ( FIFO2_DEPTH ),
    .ADDR_WIDTH ( FIFO2_ADDR_WIDTH )
)u_FIFO_syn2(
    .sys_clk    ( sys_clk          ),
    .sys_rst_n  ( sys_rst_n        ),
    .wr_en      ( 1                ),         //  we should pay attention to this wr_en or rd_en 
    .rd_en      ( 1                ),
    .din        ( dout_RAM         ),
    .full       ( FIFO2_full       ),
    .empty      ( FIFO2_empty      ),
    .dout       ( dout_FIFO2       )
);


// next is control 
control2#(
    .WIDTH      ( CONTROL2_WIDTH )
)u_control2(
    .sys_clk    ( sys_clk    ),
    .sys_rst_n  ( sys_rst_n  ),
    .tready1    ( s_ready    ),
    .din        ( dout_FIFO2        ),
    .s_tvaild   ( s_tvaild   ),
    .s_dout     ( dout     ),
    .s_last     ( s_last     )
);

endmodule

top_tb.v

`timescale 1ns/1ps
module top_tb #(
    parameter            CONTROL1_WIDTH        =         4                      ,
    parameter            FIFO1_WIDTH           =         4                      ,
    parameter            FIFO1_DEPTH           =         8                   ,
    parameter            FIFO1_ADDR_WIDTH      =         3    ,
    parameter            NUMBER1               =         4                      ,
    parameter            NUMBER2               =         2                      ,
    parameter            RAM_WIDTH             =         4                      ,
    parameter            RAM_DEPTH             =         8                      ,
    parameter            RAM_ADDR_WIDTH        =         3      ,
    parameter            FIFO2_WIDTH           =         4                      ,
    parameter            FIFO2_DEPTH           =         8                  ,
    parameter            FIFO2_ADDR_WIDTH      =         3    ,
    parameter            CONTROL2_WIDTH        =        4
);
reg                                      sys_clk         ;
reg                                      sys_rst_n       ;
reg                                      tvaild          ;
wire                                     tready          ;
reg     [CONTROL1_WIDTH-1 : 0]           din             ;
wire    [CONTROL2_WIDTH-1 : 0]           dout            ;
wire                                     s_tvaild        ;
reg                                      s_ready         ;
wire                                     s_last          ; 



dig_top#(
    .CONTROL1_WIDTH   ( CONTROL1_WIDTH ),
    .FIFO1_WIDTH      ( FIFO1_WIDTH ),
    .FIFO1_DEPTH      ( FIFO1_DEPTH ),
    .FIFO1_ADDR_WIDTH ( FIFO1_ADDR_WIDTH ),
    .NUMBER1          ( NUMBER1 ),
    .NUMBER2          ( NUMBER2 ),
    .RAM_WIDTH        ( RAM_WIDTH ),
    .RAM_DEPTH        ( RAM_DEPTH ),
    .RAM_ADDR_WIDTH   ( RAM_ADDR_WIDTH ),
    .FIFO2_WIDTH      ( FIFO2_WIDTH ),
    .FIFO2_DEPTH      ( FIFO2_DEPTH ),
    .FIFO2_ADDR_WIDTH ( FIFO2_ADDR_WIDTH ),
    .CONTROL2_WIDTH   ( CONTROL2_WIDTH  )
)u_dig_top(
    .sys_clk          ( sys_clk          ),
    .sys_rst_n        ( sys_rst_n        ),
    .tvaild           ( tvaild           ),
    .tready           ( tready           ),
    .din              ( din              ),
    .dout             ( dout             ),
    .s_tvaild         ( s_tvaild         ),
    .s_ready          ( s_ready          ),
    .s_last           ( s_last           )
);

//input                                      sys_clk    ,
//input                                      sys_rst_n  ,
//input                                      tvaild     ,
//input     [CONTROL1_WIDTH-1 : 0]           din        ,
//input                                      s_ready    ,

always  #5 sys_clk = ~sys_clk      ;
initial begin 
    sys_clk   =   0  ;
    sys_rst_n  =  1 ;
    tvaild =  0 ;
    din = 4'b0010 ;
    s_ready = 0 ;


    #10
    sys_rst_n   =  1  ; 
    
    #10 
    sys_rst_n   =  0  ; 

    #10
    sys_rst_n   =  1  ; 
    tvaild =  1;
    din = 4'b0110 ;
    s_ready = 1 ;


end
endmodule
ZxsLoves
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AMBA_AHB.rar_AHB VERILOG_ahb_ahb-to-ahb_amba ahb_amba ahb veri
09-24
标题 "AMBA_AHB.rar_AHB VERILOG_ahb_ahb-to-ahb_amba ahb_amba ahb veri" 提供的信息是关于使用Verilog硬件描述语言（HDL）实现AMBA（Advanced Microcontroller Bus Architecture）AHB（Advanced High-performance ...
应用笔记LAT1224+S2-LP的FIFO机制
03-15
在实际操作中，若要通过S2-LP发送500字节的数据，可以通过连续监测TX_AFTHR和TX_AETHR来控制数据流，即在TX_AFTHR中断触发时及时发送数据，在TX_AETHR中断触发时补充新的数据进入TX FIFO。 ##### 2.2 RX FIFO（接收...
AD_TO_FIFO.rar_AD TO FIFO_ad_fifo_数据缓存_采集
07-13
在“AD_TO_FIFO.v”这个Verilog文件中，我们可以预期找到实现这种功能的硬件描述语言（HDL）代码。Verilog是电子设计自动化（EDA）中广泛使用的编程语言，用于创建数字电路的模型。该代码可能会定义ADC接口、FIFO...
异步FIFO的Verilog代码实现-包含将满和将空判断信号
10-09
异步fifo的verilog实现 该资源是实现了的通过异步fifo进行跨时钟域传输的Quartus2工程,在不同的时钟域进行fifo数据读写,并用读写地址的格雷码判断fifo空满产生以及将空将满信号产生。
Slave_FIFO.zip_CY7C68013A_FX2-Slave-FIFO_Slave_FIFO_out
09-21
"Slave_FIFO.zip_CY7C68013A_FX2-Slave-FIFO_Slave_FIFO_out" 这个标题表明这是一个关于CY7C68013A芯片的FX2 Slave FIFO（从模式FIFO）应用的资料，其中“_out”可能指的是该实现侧重于数据输出功能。Slave FIFO通常...
FPGA——VGA协议
weixin_44569216的博客
08-29 1349
用于FPGA学习——从硬件角度来讲解VGA协议
Verilog基础，原码，反码与补码的概念
FPGA/数字IC/通信算法
09-04 1006
Verilog中的module可以看成一个具有输入输出端口的黑盒子，该黑盒子有输入和输出接口(信号)，通过把输入在盒子中执行某些操作来实现某项功能。(类似于C语言中的函数)图1 模块示意图图1 所示的顶层模块(top_module)结构用Verilog语言可描述为：input a,input b,output outendmodule🔹 模块以module 开始，endmodule结束🔹 top_module 为模块名🔹 input : 为输入端口🔹 output: 为输出端口。
FPGA开发：Verilog数字设计基础
qq_74114817的博客
09-03 2193
IP核，全称知识产权核（Intellectual Property core），在集成电路设计领域中扮演着重要角色。通俗地解释，IP核就是那些已经设计好、验证过，并可以重复使用的电路功能模块或设计模块。它们就像是构建积木一样，可以被设计师们用来快速搭建出复杂的集成电路系统，从而大大缩短设计周期，提高设计效率。软IP固IP（Firm IP Core）和硬IP软IP软IP通常是用硬件描述语言（如VHDL或Verilog）编写的功能描述，它只定义了电路的行为和功能，而不涉及具体的电路实现细节。
FPGA随记---inout端口的处理
m0_59337107的博客
09-02 912
为了进一步考虑，当一个模块的inout端口作为输出时，那么另一个模块的inout端口必须作为输入；反之，当一个模块的inout口用作输入时，那么另一个模块的inout口一定是输出口。那么，连接到inout口的另一个模块是什么情况呢？显然，另一个模块也应该是一个inout端口，一个inout端口不能独立存在。解决这个问题的方法是将DataIn声明为reg类型，将reg类型变量复制到always进程块中，需要添加一个控制信号，由always敏感表监控，保证inout端口的输出不能直接贯通到Datain处。
Verilog中编写注意事项及代码风格
weixin_38786847的博客
09-03 558
（1）大小写敏感；（2）编译指令中的前导符号；
如何设计实现完成一个FPGA项目
最新发布
QQ_778132974的博客
09-07 441
确定项目目标：明确项目要实现的功能和性能指标。需求分析：列出所有功能需求、性能需求、接口需求等。可行性分析：评估技术可行性、成本和时间预算。项目总结：总结项目过程中的经验教训，分析成功和失败的原因。项目报告：撰写项目报告，详细描述项目背景、设计过程、测试结果和最终结论。
Xilinx FPGA在线升级——升级思路
柳柳的博客
08-30 789
本文简述在线升级的思路
FIFO求和实验
m0_66619666的博客
09-04 883
现有一5行4列数据矩阵FIFO求和，对该矩阵数据，N = 5，M = 4，使X = 3进行列求和运算，得到S(3,4)新矩阵，则S(0,0)=D(0,0)+D(1,0)+D(2,0),S(0,1)= D(0,1)+D(1,1)+D(2,1),S(0,2)=D(0,2)+D(1,2)+D(2,2),S(0,3)=SD(0,3)+D(1,3)+D(2,3),S(1,0)=D(1,0)+D(2,0)+D(3,0)...S(2,0)=D(2,0)+D(3,0)+D(4,0)。
DDS基本原理--FPGA学习笔记
Hilaryw的博客
09-04 499
DDS信号发生器原理：
基于FPGA实现SD NAND FLASH的SPI协议读写
shiming8879的博客
09-04 1418
SD NAND FLASH是一种非易失性存储技术，具有高密度、高速度、低功耗等优点，广泛应用于嵌入式系统、移动设备、数据存储等领域。SPI协议作为一种全双工、同步的通信协议，因其简单易用、引脚占用少等特点，成为SD NAND FLASH等外设与FPGA通信的常用方式。在FPGA代码中，首先需要定义SPI接口的信号，包括CS、SCLK、MOSI、MISO等。这些信号通常被定义为寄存器或线网类型，以便在后续的代码中进行操作。
verilog仿真激励
weixin_51418325的博客
09-04 1207
本章节主要描述verilog激励仿真介绍，并携带仿真结果分析。 主要针对寄存器初始化值，基本所有仿真都会使用到该语句，使用如下： repeat 重复有限次数地执行一段代码，使用如下： 例如重复执行5个时钟周期时钟； always # 重复执行，一般使用在时钟上，例如实现一个100MHz系统时钟，使用如下： forever 重复执行，与always有所不同，使用如下： forever和alw
1分钟 快速掌握 双向信号(inout信号)
mengzaishenqiu的博客
09-04 834
三态门，简单来说，是一种具有三种输出状态的逻辑门电路，即逻辑“0”、逻辑“1”和高阻态（High Impedance，通常用字母“Z”表示）。在正常的逻辑电路中，输出只有“0”和“1”两种状态，但三态门增加了高阻态这一特殊状态，使得电路在某些情况下可以呈现出高阻抗的特性，就好像电路被断开一样。这种特性使得三态门在总线通信、数据选择等场景中有着广泛的应用。
Xilinx FPGA 原语解析（三）：OBUFDS差分输出缓冲器（示例源码及仿真）
qq_45910789的博客
09-04 692
OBUFDS是一个支持低压差分信号的单输出缓冲器，用于将单端信号转换为差分信号，适用于需要差分信号驱动的应用场景，如高速数据传输和时钟信号传递。本文将对其进行使用说明，实例化代码模版获取及参数说明，提供使用示例设计代码和仿真代码。
S2-LP的大数据量FIFO管控机制详解
S2-LP是一种智能硬件平台，它在设计中特别考虑了FIFO（First-In-First-Out，先进先出）机制，这对于处理数据传输至关重要。S2-LP具有两个独立的数据FIFO，一个用于数据发送（TXFIFO），另一个用于数据接收（RXFIFO）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值