AXI-STREAM 模式

kenson · 发表于 2019-4-9 21:37

本帖最后由 kenson 于 2019-4-9 21:38 编辑

https://blog.csdn.net/xdczj/article/details/72058100

kenson · 发表于 2019-4-11 21:09

http://alexforencich.com/wiki/en/verilog/axis/readme

kenson · 发表于 2019-4-11 21:11

`timescale 1 ns / 1 ps

module AXI_STREAM_IP_v1_0_S00_AXIS #
(
// Users to add parameters here

// User parameters ends
// Do not modify the parameters beyond this line

// AXI4Stream sink: Data Width
parameter integer C_S_AXIS_TDATA_WIDTH = 32
)
(
// Users to add ports here

// User ports ends
// Do not modify the ports beyond this line

// AXI4Stream sink: Clock
input wire  S_AXIS_ACLK,
// AXI4Stream sink: Reset
input wire  S_AXIS_ARESETN,
// Ready to accept data in
output wire  S_AXIS_TREADY,
// Data in
input wire [C_S_AXIS_TDATA_WIDTH-1 : 0] S_AXIS_TDATA,
// Byte qualifier
input wire [(C_S_AXIS_TDATA_WIDTH/8)-1 : 0] S_AXIS_TSTRB,
// Indicates boundary of last packet
input wire  S_AXIS_TLAST,
// Data is in valid
input wire  S_AXIS_TVALID
);
// function called clogb2 that returns an integer which has the
// value of the ceiling of the log base 2.
function integer clogb2 (input integer bit_depth);
   begin
      for(clogb2=0; bit_depth>0; clogb2=clogb2+1)
      bit_depth = bit_depth >> 1;
   end
endfunction

// Total number of input data.
localparam NUMBER_OF_INPUT_WORDS  = 8;
// bit_num gives the minimum number of bits needed to address 'NUMBER_OF_INPUT_WORDS' size of FIFO.
localparam bit_num  = clogb2(NUMBER_OF_INPUT_WORDS-1);
// Define the states of state machine
// The control state machine oversees the writing of input streaming data to the FIFO,
// and outputs the streaming data from the FIFO
parameter [1:0] IDLE = 1'b0,       // This is the initial/idle state

                  WRITE_FIFO  = 1'b1; // In this state FIFO is written with the
                                    // input stream data S_AXIS_TDATA
wire    axis_tready;
// State variable
reg mst_exec_state;
// FIFO implementation signals
genvar byte_index;
// FIFO write enable
wire fifo_wren;
// FIFO full flag
reg fifo_full_flag;
// FIFO write pointer
reg [bit_num-1:0] write_pointer;
// sink has accepted all the streaming data and stored in FIFO
   reg writes_done;
// I/O Connections assignments

assign S_AXIS_TREADY = axis_tready;
// Control state machine implementation
always @(posedge S_AXIS_ACLK)
begin
   if (!S_AXIS_ARESETN)
   // Synchronous reset (active low)
      begin
      mst_exec_state <= IDLE;
      end
   else
      case (mst_exec_state)
      IDLE:
         // The sink starts accepting tdata when
         // there tvalid is asserted to mark the
         // presence of valid streaming data
            if (S_AXIS_TVALID)
            begin
               mst_exec_state <= WRITE_FIFO;
            end
            else
            begin
               mst_exec_state <= IDLE;
            end
      WRITE_FIFO:
         // When the sink has accepted all the streaming input data,
         // the interface swiches functionality to a streaming master
         if (writes_done)
            begin
            mst_exec_state <= IDLE;
            end
         else
            begin
            // The sink accepts and stores tdata
            // into FIFO
            mst_exec_state <= WRITE_FIFO;
            end

      endcase
end
// AXI Streaming Sink
//
// The example design sink is always ready to accept the S_AXIS_TDATA  until
// the FIFO is not filled with NUMBER_OF_INPUT_WORDS number of input words.
assign axis_tready = ((mst_exec_state == WRITE_FIFO) && (write_pointer <= NUMBER_OF_INPUT_WORDS-1));

always@(posedge S_AXIS_ACLK)
begin
   if(!S_AXIS_ARESETN)
      begin
      write_pointer <= 0;
      writes_done <= 1'b0;
      end
   else
      if (write_pointer <= NUMBER_OF_INPUT_WORDS-1)
      begin
         if (fifo_wren)
            begin
            // write pointer is incremented after every write to the FIFO
            // when FIFO write signal is enabled.
            write_pointer <= write_pointer + 1;
            writes_done <= 1'b0;
            end
            if ((write_pointer == NUMBER_OF_INPUT_WORDS-1)|| S_AXIS_TLAST)
            begin
               // reads_done is asserted when NUMBER_OF_INPUT_WORDS numbers of streaming data
               // has been written to the FIFO which is also marked by S_AXIS_TLAST(kept for optional usage).
               writes_done <= 1'b1;
            end
      end
end

// FIFO write enable generation
assign fifo_wren = S_AXIS_TVALID && axis_tready;

// FIFO Implementation
generate
   for(byte_index=0; byte_index<= (C_S_AXIS_TDATA_WIDTH/8-1); byte_index=byte_index+1)
   begin:FIFO_GEN

      reg  [(C_S_AXIS_TDATA_WIDTH/4)-1:0] stream_data_fifo [0 : NUMBER_OF_INPUT_WORDS-1];

      // Streaming input data is stored in FIFO

      always @( posedge S_AXIS_ACLK )
      begin
      if (fifo_wren)// && S_AXIS_TSTRB[byte_index])
         begin
            stream_data_fifo[write_pointer] <= S_AXIS_TDATA[(byte_index*8+7) -: 8];
         end
      end
   end
endgenerate

// Add user logic here

// User logic ends

endmodule

kenson · 发表于 2019-4-11 21:14

kenson · 发表于 2019-4-11 21:19

Verilog的generate的用法

生成语句可以动态的生成verilog代码，当对矢量中的多个位进行重复操作时，或者当进行多个模块的实例引用的重复操作时，或者根据参数的定义来确定程序中是否应该包含某段Verilog代码的时候，使用生成语句能大大简化程序的编写过程。
   生成语句生成的实例范围，关键字generate-endgenerate用来指定该范围。生成实例可以是以下的一个或多个类型：
   （1）模块；（2）用户定义原语；（3）门级语句；（4）连续赋值语句；（5）initial和always块。
   generate语句有generate-for，generate-if，generate-case三种语句。
generate-for语句
（1) 必须有genvar关键字定义for语句的变量。
（2）for语句的内容必须加begin和end（即使就一句）。
（3）for语句必须有个名字。
例1：assign语句实现
module test(bin,gray);
   parameter SIZE=8;
   output [SIZE-1:0] bin;
   input [SIZE-1:0] gray;
   genvar i; //genvar i;也可以定义到generate语句里面
   generate
            for(i=0;i<SIZE;i=i+1)
            begin:bit
                  assign bin=^gray[SIZE-1:i];! \9 I# j! B4 |& S; h- _
            end( s4 S/ }6 x8 H, k9 B6 K
   endgenerate
7 s' T7 u3 D$ _9 ?7 X4 T  m* Z( |endmodule
7 y7 v5 `2 W. V等同于下面语句
, ~, c: c1 d/ V+ ~0 f, |+ Iassign bin[0]=^gray[SIZE-1:0];; `8 g- o1 Z5 P  L/ L/ L' X& N! y
assign bin[1]=^gray[SIZE-1:1];) \  q: m2 e; b9 q) t3 D
assign bin[2]=^gray[SIZE-1:2];. ]1 \$ Z! r5 D. C: {
assign bin[3]=^gray[SIZE-1:3];
/ _% s. O! D6 c6 s3 Q  q$ a1 ]assign bin[4]=^gray[SIZE-1:4];2 W# G( g9 r# m9 L8 q3 I' F4 H' @
assign bin[5]=^gray[SIZE-1:5];" {) O  g5 B: \2 h8 n2 s1 f
assign bin[6]=^gray[SIZE-1:6];6 }- H! P$ K+ [6 G. Q
assign bin[7]=^gray[SIZE-1:7];- {/ K6 c- V* z$ d5 q3 v4 X
例2:; C9 O% w1 s& F
generate
" V1 |. ]' h, q. C2 R) o. W+ Q    genvar i;
& ^& S9 N; B. z* f. ]    for(i=0;i<SIZE;i=i+1)
9 ~  y( _/ C. w, {& X6 I    begin:shifter0 @- ^5 P0 v8 L/ l( t
            always@(posedge clk)
. f. Y- t- R8 F+ u0 Q' o) D, w                   shifter<=(i==0)?din:shifter[i-1];$ F: [8 Y2 J5 j" a; e2 F/ V
   end, N! T9 ?8 J2 d7 S, T6 }
endgenerate
8 u5 v1 _. G5 P% i; W- e% d相当于& m3 [/ i& @( q7 O2 T
always@(posedge clk)7 l2 j' p7 U* S& t5 B" ^9 C
   shifter[0]<=din;6 p# n6 l, ^/ `0 b
always@(posedge clk). S6 ~5 f7 X1 R; z) [) I
   shifter[1]<=shifter[0];
$ ^! [; s/ o" e& calways@(posedge clk)
- _9 N0 a) L& [% D5 k9 h    shifter[2]<=shifter[1];
8 G- g" V( N- N* a- q" f- s.................3 `: t& _; d% K
   ......................0 q9 a; E) |2 Y" O! K, ^
always@(posedge clk)# `0 @5 b* W( h5 y8 w% a
   shifter[SIZE]<=shifter[SIZE-1];
5 Z0 S6 y/ D3 A' t8 Igenerate-if，generate-case和generate-for语句类似。' b5 U( \1 R4 {+ v

6 F1 R# v! ~1 G3 Y  ?, H转载自：http://lihaichuan.blog.51cto.com/498079/1118866- _* G5 s! l' {. n3 b8 n  o' [
5 K: w% b1 G3 a, z( z& A

3 O* c* e( _9 V7 o" T# V

kenson · 发表于 2019-4-12 10:48

Verilog之function使用说明
1.function的定义

function [range] function_name;
input_declaration
other_declarations
procedural_statement
endfunction

(1)函数通过关键词 function 和 endfunction 定义；
(2)不允许输出端口声明（包括输出和双向端口）；但可以有多个输入端口；

(3)[range]参数指定函数返回值的类型或位宽，是一个可选项，若没有指定，默认缺省值为宽度 1 比特的寄存器数据

(4)function_name为所定义函数的名称，对函数的调用也是通过函数名完成的，并在函数结构体内部代表一个内部变量，函数调用的返回值就是通过函数名变量传递给调用语句。函数定义在函数内部会隐式定义一个寄存器变量，该寄存器变量和函数同名并且位宽也一致。函数通过在函数定义中对该寄存器的显式赋值来返回函数计算结果

(5)input_declaration 为各个输入端口的位宽和类型进行说明，在函数定义中至少要有一个输入端口

注意事项：

（1）函数定义只能在模块中完成，不能出现在过程块中；

（2）函数至少要有一个输入端口；不能包含输出端口和双向端口；

（3）在函数结构中，不能使用任何形式的时间控制语句（#、 wait 等），也不能使用 disable中止语句；

（4）函数定义结构体中不能出现过程块语句（always 语句）；

（5）函数内部可以调用函数，但不能调用任务。

2.函数的调用

func_name(expr1, expr2, ........., exprN),

expr1, expr2, ......exprN是传递给函数的输入参数列表，该输入参数列表的顺序必须与函数定义时声明其输入的顺序相同.

  在函数调用中，有下列几点需要注意：
  （1）函数调用可以在过程块中完成，也可以在 assign 这样的连续赋值语句中出现。
  （2）函数调用语句不能单独作为一条语句出现，只能作为赋值语句的右端操作数。

   如果task或者function在不同地方并发调用，则它们使用同一组变量个内存地址，存在冲突产生错误。为避免错误，声明时在task和function后面加上automatic 关键字。如：task automatic task_id ........ endtask

调用例子：

在过程语句always模块内调用，

`timescale 1ns / 100ps

module lfsr (clk, ena, nReset, rst, q);

//
// parameters
//
parameter [3:0] TAPS = 8;             // number of flip-flops in LFSR

//
// inputs & outputs
//
input clk;                               // master clock
input ena;                               // clock enable
input nReset;                            // asynchronous active low reset
input rst;                               // synchronous active high reset

output [TAPS:1] q;                      // LFSR output
reg [TAPS:1] q;

//
// Module body
//
function lsb;
   input [TAPS-1:0] q;

   case (TAPS)
         2: lsb = ~q[0];
         3: lsb = q[3] ^ q[2];
         4: lsb = q[4] ^ q[3];
         5: lsb = q[5] ^ q[3];
         6: lsb = q[6] ^ q[5];
         7: lsb = q[7] ^ q[6];
         8: lsb = q[8] ^ q[6] ^ q[5] ^ q[4];
         9: lsb = q[9] ^ q[5];
      10: lsb = q[10] ^ q[7];
      11: lsb = q[11] ^ q[9];
      12: lsb = q[12] ^ q[6] ^ q[4] ^ q[1];
      13: lsb = q[13] ^ q[4] ^ q[3] ^ q[1];
      14: lsb = q[14] ^ q[5] ^ q[3] ^ q[1];
      15: lsb = q[15] ^ q[14];
      16: lsb = q[16] ^ q[15] ^ q[13] ^ q[4];
   endcase
endfunction

always @(posedge clk or negedge nReset)
   if (~nReset) q <= #1 0;
   else if (rst) q <= #1 0;
   else if (ena) q <= #1 {q[TAPS-1:1], lsb(q)};
endmodule
---------------------
作者：罗马教皇@
来源：CSDN
原文：https://blog.csdn.net/HengZo/article/details/49688677
版权声明：本文为博主原创文章，转载请附上博文链接！

kenson · 发表于 2019-4-12 18:09

http://chenyu97.cn/2018/12/20/FP ... %E6%80%BB%E7%BA%BF/

		自动登录	找回密码
密码			请使用微信账号登录和注册会员

AXI-STREAM 模式

浏览过的版块