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];
8 q) K' v4 q  N) g             end/ a5 e& ^7 L% g' _1 ]4 L
   endgenerate
* y' W  K: _9 e! J+ B0 Jendmodule
: j6 G, X7 q5 G2 E6 |9 Q等同于下面语句
1 x8 T& `9 e8 X9 {/ N4 s- aassign bin[0]=^gray[SIZE-1:0];
$ U. X' c$ O" j- K2 t+ _! h8 p' Oassign bin[1]=^gray[SIZE-1:1];# i* l* |# `, S0 L7 Y9 ]) Z
assign bin[2]=^gray[SIZE-1:2];# G9 l. S3 j5 a, Q6 g6 m
assign bin[3]=^gray[SIZE-1:3];* t9 Z5 m- ^3 l
assign bin[4]=^gray[SIZE-1:4];
( G% U4 h9 b$ c( Fassign bin[5]=^gray[SIZE-1:5];
assign bin[6]=^gray[SIZE-1:6];2 V) G, V9 S# R" _, u: F
assign bin[7]=^gray[SIZE-1:7];
" p5 I/ W+ k! ~0 G: ^! h例2:
6 o" @1 [3 L% `. M3 X8 M& Jgenerate' D/ E5 A0 |% k
   genvar i;
2 R, L; s9 a: d5 k) H    for(i=0;i<SIZE;i=i+1)7 u0 ?; r& O$ C. E. g7 \8 M
   begin:shifter
* ~5 _; W7 d% ]" U9 G. m             always@(posedge clk)) D" I( O2 e& D! v9 _$ `7 {/ N
                  shifter<=(i==0)?din:shifter[i-1];; {4 ]4 l3 V& ?* ?$ i' d0 ^
   end
& H& J' `' M. O9 f! Hendgenerate
7 H4 J5 P+ n9 p. y5 Y5 Y8 O5 e0 v相当于2 B6 _2 O6 W- h9 n5 |2 I3 Z
always@(posedge clk)( g3 B% l: r5 }2 t& @
   shifter[0]<=din;
4 G$ m9 }5 w0 q" Talways@(posedge clk)1 O) _% ]1 I7 A- b
   shifter[1]<=shifter[0];% T- F* L; W3 l! c; |
always@(posedge clk)8 o: B$ V2 N% p; b7 o0 O$ a
   shifter[2]<=shifter[1];
0 g, b' {: Q$ F, o5 w.................
; Y4 F9 u% O1 z& ^! x  w. |! \    ......................
/ s# b0 Y4 @$ K: [' k$ I6 j* ^$ Qalways@(posedge clk)( L7 ~& g( Z* k9 t2 t3 t
   shifter[SIZE]<=shifter[SIZE-1];
8 E: r6 f3 W. F8 P2 y7 _" Dgenerate-if，generate-case和generate-for语句类似。
! [: o: I" M/ j! `# q8 J1 J  p
: ^5 c* `! L( h6 I: |转载自：http://lihaichuan.blog.51cto.com/498079/11188665 J/ p- F( i: A) v. s% h9 _
, ?* M% e6 I$ J/ s/ J. ^3 N1 K

+ `$ b) c( m% S  B) H

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

浏览过的版块