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];" c' x; r7 U5 A( S$ ]+ W
            end
/ Y: O# z) l' F5 `( k8 f    endgenerate
! U2 [1 S* ]' ]3 ^endmodule    # T4 f; H4 `1 x" F: Z+ z& V
等同于下面语句( H9 M. F1 G: [; D; S
assign bin[0]=^gray[SIZE-1:0];
) v9 T1 e* d; `5 |6 sassign bin[1]=^gray[SIZE-1:1];
0 V4 {  q: B" y  t# `/ S! S' xassign bin[2]=^gray[SIZE-1:2];
2 m! Z6 G8 ?! W, _" y3 {0 Cassign bin[3]=^gray[SIZE-1:3];9 p2 I/ Z5 i; W8 x+ q- S6 B1 C
assign bin[4]=^gray[SIZE-1:4];; ~) o6 N6 g, N9 `, Y2 d+ R: G/ A0 r
assign bin[5]=^gray[SIZE-1:5];
, s' `8 R* m" u, Qassign bin[6]=^gray[SIZE-1:6];# w" ]0 n8 R$ Z
assign bin[7]=^gray[SIZE-1:7];
: T$ M% ~, p! k5 Q- d' e例2:
( J6 m! |% g: E3 l9 w- ]generate
0 Q9 P) @, D! S% D2 [    genvar i;0 w, T1 m( f% V/ C6 ^5 j; ?
   for(i=0;i<SIZE;i=i+1)3 F- A# }# X* i4 D: m$ |: B
   begin:shifter3 o% ~* k9 F4 o
            always@(posedge clk), m9 c- ^$ _# b; r( a
                  shifter<=(i==0)?din:shifter[i-1];
% x/ \& z" U2 {; T; p    end6 o& `! ^. n" W0 r% F# O
endgenerate. ^* Q7 [6 h+ {/ B
相当于
: s5 w% p6 F) N" e# B( valways@(posedge clk)
. ?* c* \- v2 o" ]& d    shifter[0]<=din;8 E- w9 y1 [; x" O
always@(posedge clk)( L  a! S4 M( t
   shifter[1]<=shifter[0];3 k; t  y5 [* Q, n4 i- Q
always@(posedge clk)% m4 ]( @, h6 p  K7 _! i2 L
   shifter[2]<=shifter[1];
5 |$ |, m+ v: V3 j+ A.................1 x! r9 W* o( ^: I, |# A- O
   ......................
9 A; r! _1 r2 U. walways@(posedge clk)
$ v% W0 _: j7 `& Z& R& X    shifter[SIZE]<=shifter[SIZE-1];3 s' G7 W- Y5 J1 a& @7 y
generate-if，generate-case和generate-for语句类似。
5 L( t" N8 M0 r7 h  a% h  w  |9 i: y9 j
转载自：http://lihaichuan.blog.51cto.com/498079/11188664 G+ K' {2 x' {9 |1 z4 e: u; g5 x

8 |' Z6 t+ P2 ^# V' o9 ]0 h  Q# r- }, |. H3 y1 W# t

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/

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