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];
7 @5 g$ {" s" [3 g* N$ Q) |             end5 P; Y$ t  x1 ~) w" `& `
   endgenerate
8 O2 Y' @- o# m. t. M) Y- eendmodule    3 E5 R2 s3 k6 @. b( N7 |
等同于下面语句
; ?9 i9 E6 D. F3 }0 M  h6 `assign bin[0]=^gray[SIZE-1:0];
+ s. l; c+ }) V3 Gassign bin[1]=^gray[SIZE-1:1];% q% [$ T: j& _
assign bin[2]=^gray[SIZE-1:2];; M5 C  m% ~, C7 ^9 s  y4 i+ \
assign bin[3]=^gray[SIZE-1:3];
6 Y7 K0 U8 s' ^# ?! V5 k: n" Sassign bin[4]=^gray[SIZE-1:4];
% j$ ?% K, D6 ~' f) k$ J- fassign bin[5]=^gray[SIZE-1:5];' ~' K+ a: ?& _! y
assign bin[6]=^gray[SIZE-1:6];- D5 ], o) c8 ]1 ?- N8 ?8 X7 B( J
assign bin[7]=^gray[SIZE-1:7];3 h8 h: I$ B  b
例2:7 y. a6 R) k7 ~5 w9 V
generate
4 Z" |4 X, m( ]( i: G; K+ l    genvar i;5 M5 Y$ P/ B7 N! p
   for(i=0;i<SIZE;i=i+1)# V% m# @3 r6 W- L$ v4 o$ p. q
   begin:shifter
2 z! t. r8 k& H# B: ?1 B4 |             always@(posedge clk)
. P1 \1 Y! F- \/ w, k% U1 f6 g                   shifter<=(i==0)?din:shifter[i-1];4 L- j$ Y# H  R3 [$ n0 t
   end
  f. M/ r9 G6 p( u& Q& Iendgenerate( {* S6 Y! ]. p! g4 `
相当于# M; r0 R/ E/ e+ V3 ~6 ~% R
always@(posedge clk)
- f3 J7 W; I, x' v' d+ ?! f  D    shifter[0]<=din;
8 Q6 K2 k0 P% ?: H/ ealways@(posedge clk)7 ~+ n) i* [; v! h( H, n
   shifter[1]<=shifter[0];
1 f9 U: Q4 n( J# V; G( f+ valways@(posedge clk)1 M+ ~; a/ \! I0 F7 ^% U( n
   shifter[2]<=shifter[1];/ W& E+ k1 u" _+ Z5 a4 L9 X
.................
5 _2 e' u" |. `" X$ y# Z$ T+ K    ......................
: t; m% W0 g0 valways@(posedge clk)2 f0 D  }% H1 x4 w
   shifter[SIZE]<=shifter[SIZE-1];
5 [  h4 n' w9 a; Fgenerate-if，generate-case和generate-for语句类似。8 T5 q( |; r/ k5 l$ q/ s- e; z

$ O: P5 o# k/ E+ Y" b; `" s# r转载自：http://lihaichuan.blog.51cto.com/498079/1118866
9 U4 V/ \" ^! {9 {6 F# X# W( Z
8 |. {& x- S/ t9 Y, i9 t. b4 T8 ]# _, T( @- O( m1 {2 a

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/

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