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 q- Q- K* s/ f$ W3 r/ Z- n& r
            end
' A! S6 V, O  c; |. A6 d& A  E    endgenerate! u7 N6 K1 }8 R! l5 C
endmodule    * P: u! ^. ]0 a3 N
等同于下面语句
/ _+ v6 R0 e9 w0 L+ Sassign bin[0]=^gray[SIZE-1:0];- A' G* k' Y0 c# M9 ]5 Y
assign bin[1]=^gray[SIZE-1:1];! Y1 ]1 j5 S5 g: {2 Q) u
assign bin[2]=^gray[SIZE-1:2];* D4 M! u# }- n' o2 y6 h' Y; P$ W6 D0 G
assign bin[3]=^gray[SIZE-1:3];8 ?. g# X4 Q( G* y" S' J. K
assign bin[4]=^gray[SIZE-1:4];
& h' e5 b4 F2 L8 T6 U( F" sassign bin[5]=^gray[SIZE-1:5];% F: Q( a. T- A
assign bin[6]=^gray[SIZE-1:6];
* k3 Y# b5 Y8 L  W& W0 s& Gassign bin[7]=^gray[SIZE-1:7];  d$ `; A/ j2 e* S: g
例2:5 c: z* l  X) ], f1 T& q8 x
generate
# F* P- c1 s. ^    genvar i;: b" _: O) n0 G2 V9 E2 m& P
   for(i=0;i<SIZE;i=i+1)
7 r. Y5 B# A7 G0 f8 M1 P2 Q2 S4 A    begin:shifter
" v, k7 n- P$ s3 ^1 ^             always@(posedge clk)% }2 U$ s  e8 ^0 j- [  s
                  shifter<=(i==0)?din:shifter[i-1];9 v: g4 k8 y, k& J' M3 w+ _2 w
   end
, p0 z7 M3 r% i' J* E, N* M, pendgenerate3 E5 w1 W$ ]$ L
相当于
1 u7 A" N! \& p* W) O' yalways@(posedge clk)
( X  p0 E+ I& m0 F2 L$ o8 Z8 ?    shifter[0]<=din;
$ N$ v' Z$ Y' Y: O- ialways@(posedge clk)9 u% h% J$ ^& I* x
   shifter[1]<=shifter[0];# c: S4 m" y0 d8 t! p; ]
always@(posedge clk)
7 T  I. C5 S# C) K9 `" K    shifter[2]<=shifter[1];* P0 d' e) m$ G* [) i
.................8 c, M1 Y& L1 F9 x6 E' Y* ^: E
   ......................
7 _. I* B2 w; d5 Z5 X& k% S! Ralways@(posedge clk)
6 j+ \% f; u. V8 a+ R' T    shifter[SIZE]<=shifter[SIZE-1];/ C/ F$ i& a, Q( s& z% A
generate-if，generate-case和generate-for语句类似。
* }& ^1 V4 Q- g; K
  `0 d, N. b' G$ h; r转载自：http://lihaichuan.blog.51cto.com/498079/1118866
* P  b3 J" n; H* H4 K0 i, H
8 T4 x3 R  V' b
, Q  `& |; q1 G5 w: r: N% P- h, n

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 模式

浏览过的版块