FC2カウンター FPGAの部屋 2013年07月03日
FC2ブログ

FPGAやCPLDの話題やFPGA用のツールの話題などです。 マニアックです。 日記も書きます。

FPGAの部屋

FPGAの部屋の有用と思われるコンテンツのまとめサイトを作りました。Xilinx ISEの初心者の方には、FPGAリテラシーおよびチュートリアルのページをお勧めいたします。

お神輿用LED配線基板を一部実装した

お神輿用LED配線基板が来ました”で来た基板を切り離し、ターミナルやミニUSB-Bコネクタ、抵抗、LEDを実装してみた。
kiban_2_130703.jpg

USB電源をつないでLEDを点灯させてみた。左の白いLEDは下に2灯あるので、合計4灯だ。右のRGBイルミネーション・フルカラーLEDは2灯だ。
kiban_3_130703.jpg

白色LEDは、超高輝度白色LED5mm OSPW5111A-YZ 10個入を電源電圧+5V、直列抵抗150Ωで使用している。それを4個束ねている。(左側のLED)

右側のRGBイルミネーション・フルカラーLEDは、RGBイルミネーション・フルカラーLED 5mm乳白色ボディ OST1MK5A32A (10個入)を使用している。最大定格が+5Vだが、+5Vに直接接続すると、LEDが熱くなってしまう。そのため、150Ω並列 x 2 = 75Ωで使用している。こうすると白色は出ないが、発熱は感じない。なお、37.5Ωにすると白が出るが、75Ωで使用している。

左の白色LED4灯の消費電流は約50mAで、提灯の中に入れて提灯照明として使用する。
右のRGBイルミネーション・フルカラーLED2灯は、神輿の天辺に付いている鳳凰の羽の部分に、ゴムの両面テープで止める予定だ。色が変わりながら、神輿を担いだ時に揺れるのが良いのでは?と思う。
  1. 2013年07月03日 20:35 |
  2. プリント基板作成
  3. | トラックバック:0
  4. | コメント:0

AXI4 Slave インターフェースのメモリ・シミュレーション用 IP の作製3(テストベンチ)

AXI4 Slave インターフェースのメモリ・シミュレーション用 IP の作製2(シミュレーション)”の続き。

前回、ブログに貼れなかったテストベンチとOVLチェッカーを貼っておく。

最初に、テストベンチ (mem_sim_axi_slave_tb.v ) を下に貼る。

`default_nettype none

`timescale 100ps / 1ps

////////////////////////////////////////////////////////////////////////////////
// Company: 
// Engineer:
//
// Create Date:   04:01:46 06/27/2013
// Design Name:   mem_sim_axi_slave
// Module Name:   D:/HDL/FndtnISEWork/Zynq-7000/ZedBoard/test/mem_sim_axi_slave/mem_sim_axi_slave_tb.v
// Project Name:  mem_sim_axi_slave
// Target Device:  
// Tool versions:  
// Description: 
//
// Verilog Test Fixture created by ISE for module: mem_sim_axi_slave
//
// Dependencies:
// 
// Revision:
// Revision 0.01 - File Created
// Additional Comments:
// 
////////////////////////////////////////////////////////////////////////////////

module mem_sim_axi_slave_tb;
    
    parameter DELAY    = 10;
    parameter NUMBER_OF_TEST = 100;    // テストする数
    
    parameter    ASIZE_BT_4    = 3'd2;    // 32 bit width
    parameter    ASIZE_BT_2 = 3'd1;    // 16 bit width
    parameter    ASIZE_BT_1 = 3'd0;    // 8 bit width
    
    parameter    ABURST_FIXED    = 2'd0;
    parameter    ABURST_INCR    = 2'd1;
    parameter    ABURST_WRAP    = 2'd2;
    
    parameter    BRESP_OKAY        = 2'b00;
    parameter    BRESP_EXOKAY    = 2'b01;
    parameter    BRESP_SLVERR    = 2'b10;
    parameter    BRESP_DECERR    = 2'b11;

    // Inputs
    wire ACLK;
    wire ARESETN;
    wire [0:0] S_AXI_AWID;
    wire [31:0] S_AXI_AWADDR;
    wire [7:0] S_AXI_AWLEN;
    wire [2:0] S_AXI_AWSIZE;
    wire [1:0] S_AXI_AWBURST;
    wire [1:0] S_AXI_AWLOCK;
    wire [3:0] S_AXI_AWCACHE;
    wire [2:0] S_AXI_AWPROT;
    wire [3:0] S_AXI_AWREGION;
    wire [3:0] S_AXI_AWQOS;
    wire [0:0] S_AXI_AWUSER;
    wire S_AXI_AWVALID;
    wire [0:0] S_AXI_WID;
    wire [31:0] S_AXI_WDATA;
    wire [3:0] S_AXI_WSTRB;
    wire S_AXI_WLAST;
    wire [0:0] S_AXI_WUSER;
    wire S_AXI_WVALID;
    wire S_AXI_BREADY;
    wire [0:0] S_AXI_ARID;
    wire [31:0] S_AXI_ARADDR;
    wire [7:0] S_AXI_ARLEN;
    wire [2:0] S_AXI_ARSIZE;
    wire [1:0] S_AXI_ARBURST;
    wire [1:0] S_AXI_ARLOCK;
    wire [3:0] S_AXI_ARCACHE;
    wire [2:0] S_AXI_ARPROT;
    wire [3:0] S_AXI_ARREGION;
    wire [3:0] S_AXI_ARQOS;
    wire [0:0] S_AXI_ARUSER;
    wire S_AXI_ARVALID;
    wire S_AXI_RREADY;

    // Outputs
    reg S_AXI_AWREADY;
    reg S_AXI_WREADY;
    reg [0:0] S_AXI_BID;
    reg [1:0] S_AXI_BRESP;
    wire [0:0] S_AXI_BUSER = 0;
    reg S_AXI_BVALID;
    reg S_AXI_ARREADY;
    reg [0:0] S_AXI_RID;
    reg [31:0] S_AXI_RDATA;
    reg [1:0] S_AXI_RRESP;
    reg S_AXI_RLAST;
    wire [0:0] S_AXI_RUSER = 0;
    reg S_AXI_RVALID;

    wire S_AXI_AWREADY_d;
    wire S_AXI_WREADY_d;
    wire [0:0]    S_AXI_BID_d;
    wire [1:0]    S_AXI_BRESP_d;
    wire S_AXI_BVALID_d;
    wire S_AXI_ARREADY_d;
    wire [0:0]    S_AXI_RID_d;
    wire [31:0]    S_AXI_RDATA_d;
    wire [1:0]    S_AXI_RRESP_d;
    wire S_AXI_RLAST_d;
    wire S_AXI_RVALID_d;
    
    // Instantiate the Unit Under Test (UUT)
    mem_sim_axi_slave #(
        .C_MEMORY_SIZE(1024)
    ) UUT (
        .ACLK(ACLK), 
        .ARESETN(ARESETN), 
        .S_AXI_AWID(S_AXI_AWID), 
        .S_AXI_AWADDR(S_AXI_AWADDR), 
        .S_AXI_AWLEN(S_AXI_AWLEN), 
        .S_AXI_AWSIZE(S_AXI_AWSIZE), 
        .S_AXI_AWBURST(S_AXI_AWBURST), 
        .S_AXI_AWLOCK(S_AXI_AWLOCK), 
        .S_AXI_AWCACHE(S_AXI_AWCACHE), 
        .S_AXI_AWPROT(S_AXI_AWPROT), 
        .S_AXI_AWREGION(S_AXI_AWREGION), 
        .S_AXI_AWQOS(S_AXI_AWQOS), 
        .S_AXI_AWUSER(S_AXI_AWUSER), 
        .S_AXI_AWVALID(S_AXI_AWVALID), 
        .S_AXI_AWREADY(S_AXI_AWREADY_d), 
        .S_AXI_WID(S_AXI_WID), 
        .S_AXI_WDATA(S_AXI_WDATA), 
        .S_AXI_WSTRB(S_AXI_WSTRB), 
        .S_AXI_WLAST(S_AXI_WLAST), 
        .S_AXI_WUSER(S_AXI_WUSER), 
        .S_AXI_WVALID(S_AXI_WVALID), 
        .S_AXI_WREADY(S_AXI_WREADY_d), 
        .S_AXI_BID(S_AXI_BID_d), 
        .S_AXI_BRESP(S_AXI_BRESP_d), 
        .S_AXI_BUSER(S_AXI_BUSER), 
        .S_AXI_BVALID(S_AXI_BVALID_d), 
        .S_AXI_BREADY(S_AXI_BREADY), 
        .S_AXI_ARID(S_AXI_ARID), 
        .S_AXI_ARADDR(S_AXI_ARADDR), 
        .S_AXI_ARLEN(S_AXI_ARLEN), 
        .S_AXI_ARSIZE(S_AXI_ARSIZE), 
        .S_AXI_ARBURST(S_AXI_ARBURST), 
        .S_AXI_ARLOCK(S_AXI_ARLOCK), 
        .S_AXI_ARCACHE(S_AXI_ARCACHE), 
        .S_AXI_ARPROT(S_AXI_ARPROT), 
        .S_AXI_ARREGION(S_AXI_ARREGION), 
        .S_AXI_ARQOS(S_AXI_ARQOS), 
        .S_AXI_ARUSER(S_AXI_ARUSER), 
        .S_AXI_ARVALID(S_AXI_ARVALID), 
        .S_AXI_ARREADY(S_AXI_ARREADY_d), 
        .S_AXI_RID(S_AXI_RID_d), 
        .S_AXI_RDATA(S_AXI_RDATA_d), 
        .S_AXI_RRESP(S_AXI_RRESP_d), 
        .S_AXI_RLAST(S_AXI_RLAST_d), 
        .S_AXI_RUSER(S_AXI_RUSER), 
        .S_AXI_RVALID(S_AXI_RVALID_d), 
        .S_AXI_RREADY(S_AXI_RREADY) 
    );
    always @* S_AXI_AWREADY <= #DELAY S_AXI_AWREADY_d;
    always @* S_AXI_WREADY <= #DELAY S_AXI_WREADY_d;
    always @* S_AXI_BID <= #DELAY S_AXI_BID_d;
    always @* S_AXI_BRESP <= #DELAY S_AXI_BRESP_d;
    always @* S_AXI_BVALID <= #DELAY S_AXI_BVALID_d;
    always @* S_AXI_ARREADY <= #DELAY S_AXI_ARREADY_d;
    always @* S_AXI_RID <= #DELAY S_AXI_RID_d;
    always @* S_AXI_RDATA <= #DELAY S_AXI_RDATA_d;
    always @* S_AXI_RRESP <= #DELAY S_AXI_RRESP_d;
    always @* S_AXI_RLAST <= #DELAY S_AXI_RLAST_d;
    always @* S_AXI_RVALID <= #DELAY S_AXI_RVALID_d;
    
    // clk_gen のインスタンス
    clk_gen #(
        .CLK_PERIOD(100),    // 10nsec, 100MHz
        .CLK_DUTY_CYCLE(0.5),
        .CLK_OFFSET(0),
        .START_STATE(1'b0)
    ) ACLKi (
        .clk_out(ACLK)
    );
    
    // reset_gen のインスタンス
    reset_gen #(
        .RESET_STATE(1'b0),
        .RESET_TIME(1000)    // 100nsec
    ) RESETi (
        .reset_out(ARESETN)
    );
    
    // AXI4_BFM のインスタンス
    AXI4_Master_BFM #(
        .DELAY(DELAY)
    ) MBFMi(
        .ACLK(ACLK), 
        .S_AXI_AWID(S_AXI_AWID), 
        .S_AXI_AWADDR(S_AXI_AWADDR), 
        .S_AXI_AWLEN(S_AXI_AWLEN), 
        .S_AXI_AWSIZE(S_AXI_AWSIZE), 
        .S_AXI_AWBURST(S_AXI_AWBURST), 
        .S_AXI_AWLOCK(S_AXI_AWLOCK), 
        .S_AXI_AWCACHE(S_AXI_AWCACHE), 
        .S_AXI_AWPROT(S_AXI_AWPROT), 
        .S_AXI_AWREGION(S_AXI_AWREGION), 
        .S_AXI_AWQOS(S_AXI_AWQOS), 
        .S_AXI_AWUSER(S_AXI_AWUSER), 
        .S_AXI_AWVALID(S_AXI_AWVALID), 
        .S_AXI_AWREADY(S_AXI_AWREADY), 
        .S_AXI_WID(S_AXI_WID), 
        .S_AXI_WDATA(S_AXI_WDATA), 
        .S_AXI_WSTRB(S_AXI_WSTRB), 
        .S_AXI_WLAST(S_AXI_WLAST), 
        .S_AXI_WUSER(S_AXI_WUSER), 
        .S_AXI_WVALID(S_AXI_WVALID), 
        .S_AXI_WREADY(S_AXI_WREADY), 
        .S_AXI_BID(S_AXI_BID), 
        .S_AXI_BRESP(S_AXI_BRESP), 
        .S_AXI_BUSER(S_AXI_BUSER), 
        .S_AXI_BVALID(S_AXI_BVALID), 
        .S_AXI_BREADY(S_AXI_BREADY), 
        .S_AXI_ARID(S_AXI_ARID), 
        .S_AXI_ARADDR(S_AXI_ARADDR), 
        .S_AXI_ARLEN(S_AXI_ARLEN), 
        .S_AXI_ARSIZE(S_AXI_ARSIZE), 
        .S_AXI_ARBURST(S_AXI_ARBURST), 
        .S_AXI_ARLOCK(S_AXI_ARLOCK), 
        .S_AXI_ARCACHE(S_AXI_ARCACHE), 
        .S_AXI_ARPROT(S_AXI_ARPROT), 
        .S_AXI_ARREGION(S_AXI_ARREGION), 
        .S_AXI_ARQOS(S_AXI_ARQOS), 
        .S_AXI_ARUSER(S_AXI_ARUSER), 
        .S_AXI_ARVALID(S_AXI_ARVALID), 
        .S_AXI_ARREADY(S_AXI_ARREADY), 
        .S_AXI_RID(S_AXI_RID), 
        .S_AXI_RDATA(S_AXI_RDATA), 
        .S_AXI_RRESP(S_AXI_RRESP), 
        .S_AXI_RLAST(S_AXI_RLAST), 
        .S_AXI_RUSER(S_AXI_RUSER), 
        .S_AXI_RVALID(S_AXI_RVALID), 
        .S_AXI_RREADY(S_AXI_RREADY)
    );
    
    // OVL Checker
    OVL_Checker OVLi (
        .ACLK(ACLK), 
        .ARESETN(ARESETN), 
        .S_AXI_AWID(S_AXI_AWID), 
        .S_AXI_AWADDR(S_AXI_AWADDR), 
        .S_AXI_AWLEN(S_AXI_AWLEN), 
        .S_AXI_AWSIZE(S_AXI_AWSIZE), 
        .S_AXI_AWBURST(S_AXI_AWBURST), 
        .S_AXI_AWLOCK(S_AXI_AWLOCK), 
        .S_AXI_AWCACHE(S_AXI_AWCACHE), 
        .S_AXI_AWPROT(S_AXI_AWPROT), 
        .S_AXI_AWREGION(S_AXI_AWREGION), 
        .S_AXI_AWQOS(S_AXI_AWQOS), 
        .S_AXI_AWUSER(S_AXI_AWUSER), 
        .S_AXI_AWVALID(S_AXI_AWVALID), 
        .S_AXI_AWREADY(S_AXI_AWREADY), 
        .S_AXI_WID(S_AXI_WID), 
        .S_AXI_WDATA(S_AXI_WDATA), 
        .S_AXI_WSTRB(S_AXI_WSTRB), 
        .S_AXI_WLAST(S_AXI_WLAST), 
        .S_AXI_WUSER(S_AXI_WUSER), 
        .S_AXI_WVALID(S_AXI_WVALID), 
        .S_AXI_WREADY(S_AXI_WREADY), 
        .S_AXI_BID(S_AXI_BID), 
        .S_AXI_BRESP(S_AXI_BRESP), 
        .S_AXI_BUSER(S_AXI_BUSER), 
        .S_AXI_BVALID(S_AXI_BVALID), 
        .S_AXI_BREADY(S_AXI_BREADY), 
        .S_AXI_ARID(S_AXI_ARID), 
        .S_AXI_ARADDR(S_AXI_ARADDR), 
        .S_AXI_ARLEN(S_AXI_ARLEN), 
        .S_AXI_ARSIZE(S_AXI_ARSIZE), 
        .S_AXI_ARBURST(S_AXI_ARBURST), 
        .S_AXI_ARLOCK(S_AXI_ARLOCK), 
        .S_AXI_ARCACHE(S_AXI_ARCACHE), 
        .S_AXI_ARPROT(S_AXI_ARPROT), 
        .S_AXI_ARREGION(S_AXI_ARREGION), 
        .S_AXI_ARQOS(S_AXI_ARQOS), 
        .S_AXI_ARUSER(S_AXI_ARUSER), 
        .S_AXI_ARVALID(S_AXI_ARVALID), 
        .S_AXI_ARREADY(S_AXI_ARREADY), 
        .S_AXI_RID(S_AXI_RID), 
        .S_AXI_RDATA(S_AXI_RDATA), 
        .S_AXI_RRESP(S_AXI_RRESP), 
        .S_AXI_RLAST(S_AXI_RLAST), 
        .S_AXI_RUSER(S_AXI_RUSER), 
        .S_AXI_RVALID(S_AXI_RVALID), 
        .S_AXI_RREADY(S_AXI_RREADY)
    );        
    
    
    // test
    
    // Write Channel
    
    // wr_data生成、+1する
    reg        [15:0]    wcount;
    wire    [31:0]    wdata;
    
    always @(posedge ACLK) begin
        if (~ARESETN)
            wcount <= 0;
        else begin
            if (S_AXI_WVALID & S_AXI_WREADY)
                wcount <= wcount + 16'd1;
        end
    end
    assign wdata = {{16{1'b0}}, wcount};

    
    reg    WriteTaskBusy = 1'b0;
    integer wt_cnt;
    initial begin
        // Wait 100 ns for global reset to finish
        #1000;
        #5000;    // 500nsec Wait, PLL Locked
        
        @(posedge ACLK);    // 次のクロックへ
        #DELAY;
        
        for (wt_cnt=0; wt_cnt<NUMBER_OF_TEST; wt_cnt=wt_cnt+1) begin
            WriteTaskBusy = 1'b1;
            MBFMi.AXI_Master_1Seq_Write(0, 32'h100, 8'd7, ASIZE_BT_4, ABURST_INCR, wdata, 0, 2);
            MBFMi.AXI_Master_1Seq_Write(0, 32'h200, 8'd3, ASIZE_BT_4, ABURST_INCR, wdata, 1, 3);
            MBFMi.AXI_Master_1Seq_Write(0, 32'h300, 8'd1, ASIZE_BT_4, ABURST_INCR, wdata, 1, 4);
            MBFMi.AXI_Master_1Seq_Write(0, 32'h400, 8'd0, ASIZE_BT_4, ABURST_INCR, wdata, 1, 5);
            
            WriteTaskBusy = 1'b0;
            while (ReadTestBusy) begin // Read 終了待ち
                @(posedge ACLK);    // 次のクロックへ
                #DELAY;
            end
            @(posedge ACLK);    // 次のクロックへ
            #DELAY;
        end
    end
    
    // Read Channel
    reg    ReadTestBusy = 1'b0;
    integer rd_cnt;
    initial begin
        // Wait 100 ns for global reset to finish
        #1000;
        #5000;    // 500nsec Wait, PLL Locked
        
        for (rd_cnt=0; rd_cnt<NUMBER_OF_TEST; rd_cnt=rd_cnt+1) begin
            
            ReadTestBusy = 1'b1;
            #1000;
            @(posedge ACLK);    // 次のクロックへ
            #DELAY;
            
            MBFMi.AXI_Master_1Seq_Read(0, 32'h100, 8'd7, ASIZE_BT_4, ABURST_INCR, 2);
            MBFMi.AXI_Master_1Seq_Read(0, 32'h200, 8'd3, ASIZE_BT_4, ABURST_INCR, 3);
            MBFMi.AXI_Master_1Seq_Read(0, 32'h300, 8'd1, ASIZE_BT_4, ABURST_INCR, 4);
            MBFMi.AXI_Master_1Seq_Read(0, 32'h400, 8'd0, ASIZE_BT_4, ABURST_INCR, 5);
            
            ReadTestBusy = 1'b0;
            while (WriteTaskBusy) begin // Write の終了待ち
                @(posedge ACLK);    // 次のクロックへ
                #DELAY;
            end
            @(posedge ACLK);    // 次のクロックへ
            #DELAY;
        end
    end
    
endmodule

module clk_gen #(
    parameter         CLK_PERIOD = 100,
    parameter real    CLK_DUTY_CYCLE = 0.5,
    parameter        CLK_OFFSET = 0,
    parameter        START_STATE    = 1'b0 )
(
    output    reg        clk_out
);
    begin
        initial begin
            #CLK_OFFSET;
            forever
            begin
                clk_out = START_STATE;
                #(CLK_PERIOD-(CLK_PERIOD*CLK_DUTY_CYCLE)) clk_out = ~START_STATE;
                #(CLK_PERIOD*CLK_DUTY_CYCLE);
            end
        end
    end
endmodule

module reset_gen #(
    parameter    RESET_STATE = 1'b1,
    parameter    RESET_TIME = 100 )
(
    output    reg        reset_out
);
    begin
        initial begin
            reset_out = RESET_STATE;
            #RESET_TIME;
            reset_out = ~RESET_STATE;
        end
    end
endmodule

`default_nettype wire


次に、OVLチェッカー (OVL_Checker.v) を貼っておく。(2013/07/12:大幅変更)

// OVL_Checker.v
// 2012/10/25:書き込みトランザクションの時に、MasterがAWREADYを待って、WVALIDをアサートしていけないというルールがあったので、修正した。
// 2013/07/12:大幅に書き換えた
//

`default_nettype none

`timescale 100ps / 1ps

`include "std_ovl_defines.h"

module OVL_Checker (
    input    wire    ACLK,
    input    wire    ARESETN,

    input wire [0:0] S_AXI_AWID,
    input wire [31:0] S_AXI_AWADDR,
    input wire [7:0] S_AXI_AWLEN,
    input wire [2:0] S_AXI_AWSIZE,
    input wire [1:0] S_AXI_AWBURST,
    input wire [1:0] S_AXI_AWLOCK,
    input wire [3:0] S_AXI_AWCACHE,    // Normal Non-cacheable Non-bufferable
    input wire [2:0] S_AXI_AWPROT,
    input wire [3:0] S_AXI_AWREGION,
    input wire [3:0] S_AXI_AWQOS,
    input wire [0:0] S_AXI_AWUSER,
    input wire S_AXI_AWVALID,
    input wire [0:0] S_AXI_WID,
    input wire [31:0] S_AXI_WDATA,
    input wire [3:0] S_AXI_WSTRB,
    input wire S_AXI_WLAST,
    input wire [0:0] S_AXI_WUSER,
    input wire S_AXI_WVALID,
    input wire S_AXI_BREADY,
    input wire [0:0] S_AXI_ARID,
    input wire [31:0] S_AXI_ARADDR,
    input wire [7:0] S_AXI_ARLEN,
    input wire [2:0] S_AXI_ARSIZE,
    input wire [1:0] S_AXI_ARBURST,
    input wire [1:0] S_AXI_ARLOCK,
    input wire [3:0] S_AXI_ARCACHE, // Normal Non-cacheable Non-bufferable
    input wire [2:0] S_AXI_ARPROT,
    input wire [3:0] S_AXI_ARREGION,
    input wire [3:0] S_AXI_ARQOS,
    input wire [0:0] S_AXI_ARUSER,
    input wire S_AXI_ARVALID,
    input wire S_AXI_RREADY,

    input wire S_AXI_AWREADY,
    input wire S_AXI_WREADY,
    input wire [0:0] S_AXI_BID,
    input wire [1:0] S_AXI_BRESP,
    input wire [0:0] S_AXI_BUSER,
    input wire S_AXI_BVALID,
    input wire S_AXI_ARREADY,
    input wire [0:0] S_AXI_RID,
    input wire [31:0] S_AXI_RDATA,
    input wire [1:0] S_AXI_RRESP,
    input wire S_AXI_RLAST,
    input wire [0:0] S_AXI_RUSER,
    input wire S_AXI_RVALID
);

    wire [`OVL_FIRE_WIDTH-1:0] fire_wr_data, fire_rd_data;
    wire [`OVL_FIRE_WIDTH-1:0] fire_aw_hcheck, fire_ar_hcheck;
    wire [`OVL_FIRE_WIDTH-1:0] fire_awvalid_cont, fire_wd_sig_assert;
    wire [`OVL_FIRE_WIDTH-1:0] fire_ar_never;
    reg        [7:0]    countw, countr;
    
    parameter    idle_wts =        3'b001,
                wr_data_tran =    3'b010,
                wr_resp_tran =    3'b100;
    reg    [2:0]    wr_tran_cs;
    
    parameter    idle_rts =        1'b0,
                rd_data_tran =    1'b1;
    reg    rd_trans_cs;
    
    reg S_AXI_WDATA_d, S_AXI_RDATA_d;
    
    // Wirte Transaction データが+1されていることをチェックする(BFM Check)
    ovl_increment #(
        `OVL_ERROR,            // severity_level
        32,                        // width
        1,                        // value
        `OVL_ASSERT,            // property_type
        "Error: Write data has not been incremented", // msg
        `OVL_COVER_DEFAULT,        // coverage_level
        `OVL_POSEDGE,            // clock_edge
        `OVL_ACTIVE_HIGH,        // reset_polarity
        `OVL_GATE_CLOCK            // gating_type
    ) wr_data_check (
        ACLK,                    // clock
        ~ARESETN | (S_AXI_AWVALID & S_AXI_AWREADY),    // reset, Write のアドレス転送でリセット
        S_AXI_WVALID & S_AXI_WREADY,                    // enable
        S_AXI_WDATA,            // test_expr
        fire_wr_data            // fire    parameter
    );
    
    // Read Transaction データが+1されていることをチェックする(BFM Check)
    ovl_increment #(
        `OVL_ERROR,            // severity_level
        32,                        // width
        1,                        // value
        `OVL_ASSERT,            // property_type
        "Error: Read data has not been incremented", // msg
        `OVL_COVER_DEFAULT,        // coverage_level
        `OVL_POSEDGE,            // clock_edge
        `OVL_ACTIVE_HIGH,        // reset_polarity
        `OVL_GATE_CLOCK            // gating_type
    ) rd_data_check (
        ACLK,                    // clock
        ~ARESETN | (S_AXI_ARVALID & S_AXI_ARREADY),    // reset, Read のアドレス転送でリセット
        S_AXI_RVALID & S_AXI_RREADY,                    // enable
        S_AXI_RDATA,            // test_expr
        fire_rd_data            // fire    parameter
    );
    
    // S_AXI_AWVALID とS_AXI_AWREADY のハンドシェークのテスト
    ovl_change #(
        `OVL_ERROR,             // severity_level 
        1,                         // width 
        1,                         // num_cks 
        `OVL_IGNORE_NEW_START,     // action_on_new_start
        `OVL_ASSERT,             // property_type
        "INFO: AWREADY invalid synchronization",// msg 
        `OVL_COVER_DEFAULT,        // coverage_level 
        `OVL_POSEDGE,            // clock_edge 
        `OVL_ACTIVE_LOW,        // reset_polarity 
        `OVL_GATE_CLOCK            // gating_type
    ) aw_valid_ready_check (
        ACLK,                      // clock 
        ARESETN,                // reset
        1'b1,                    // enable
        S_AXI_AWVALID == 1'b1,     // start_event 
        S_AXI_AWREADY,            // test_expr 
        fire_aw_hcheck            // fire    
    );

    // S_AXI_ARVALID とS_AXI_ARREADY のハンドシェークのテスト
    ovl_change #(
        `OVL_ERROR,             // severity_level 
        1,                         // width 
        1,                         // num_cks 
        `OVL_IGNORE_NEW_START,     // action_on_new_start
        `OVL_ASSERT,             // property_type
        "Error: ARREADY invalid synchronization",// msg 
        `OVL_COVER_DEFAULT,        // coverage_level 
        `OVL_POSEDGE,            // clock_edge 
        `OVL_ACTIVE_LOW,        // reset_polarity 
        `OVL_GATE_CLOCK            // gating_type
    ) ar_valid_ready_check (
        ACLK,                      // clock 
        ARESETN,                // reset
        1'b1,                    // enable
        S_AXI_ARVALID == 1'b1,     // start_event 
        S_AXI_ARREADY,            // test_expr 
        fire_ar_hcheck            // fire    
    );
    
    // Write, S_AXI_AWREADY がアサートされるとき、次のクロックでS_AXI_AWVALIDがディアサートされる(エラーではない)
    ovl_transition #(
        `OVL_INFO,                // severity_level
        1,                        // width
        `OVL_ASSERT,            // property_type
        "Info : S_AXI_AWVALID have been asserted to continue",
        `OVL_COVER_DEFAULT,        // coverage_level
        `OVL_POSEDGE,            // clock edge
        `OVL_ACTIVE_LOW,        // reset_polarity
        `OVL_GATE_CLOCK            // gating_type
    ) awvalid_cont_assert (
        ACLK,                    // clock_edge
        ARESETN,                // reset
        1'b1,                    // enable
        S_AXI_AWVALID,        // test_expr
        1'b1,                    // start_state
        (S_AXI_AWREADY == 1'b1) ? 1'b0 : 1'b1,    // next_state
        fire_awvalid_cont
    );
    
    // Write, S_AXI_WVALID, S_AXI_WLAST, S_AXI_WREADYがアサートされるとき、次のクロックで、それらの信号がディアサートされる
    ovl_change #(
        `OVL_ERROR,             // severity_level 
        1,                         // width 
        1,                         // num_cks 
        `OVL_IGNORE_NEW_START,     // action_on_new_start
        `OVL_ASSERT,             // property_type
        "Error : After S_AXI_WREADY and S_AXI_WLAST and S_AXI_WVALID is asserted at the same time, S_AXI_WVALID is not de-asserted.",// msg 
        `OVL_COVER_DEFAULT,        // coverage_level 
        `OVL_POSEDGE,            // clock_edge 
        `OVL_ACTIVE_LOW,        // reset_polarity 
        `OVL_GATE_CLOCK            // gating_type
    ) wd_sig_wvalid_assert (
        ACLK,                      // clock 
        ARESETN,                // reset
        1'b1,                    // enable
        S_AXI_WVALID==1'b1 && S_AXI_WLAST==1'b1 && S_AXI_WREADY==1'b1,     // start_event 
        S_AXI_WVALID,            // test_expr 
        fire_ar_hcheck            // fire    
    );
    
    ovl_change #(
        `OVL_ERROR,             // severity_level 
        1,                         // width 
        1,                         // num_cks 
        `OVL_IGNORE_NEW_START,     // action_on_new_start
        `OVL_ASSERT,             // property_type
        "Error : After S_AXI_WREADY and S_AXI_WLAST and S_AXI_WVALID is asserted at the same time, S_AXI_WLAST is not de-asserted.",// msg 
        `OVL_COVER_DEFAULT,        // coverage_level 
        `OVL_POSEDGE,            // clock_edge 
        `OVL_ACTIVE_LOW,        // reset_polarity 
        `OVL_GATE_CLOCK            // gating_type
    ) wd_sig_wlast_assert (
        ACLK,                      // clock 
        ARESETN,                // reset
        1'b1,                    // enable
        S_AXI_WVALID==1'b1 && S_AXI_WLAST==1'b1 && S_AXI_WREADY==1'b1,     // start_event 
        S_AXI_WLAST,            // test_expr 
        fire_ar_hcheck            // fire    
    );
    
    ovl_change #(
        `OVL_INFO,                 // severity_level 
        1,                         // width 
        1,                         // num_cks 
        `OVL_IGNORE_NEW_START,     // action_on_new_start
        `OVL_ASSERT,             // property_type
        "INFO : After S_AXI_WREADY and S_AXI_WLAST and S_AXI_WVALID is asserted at the same time, S_AXI_WREADY is not de-asserted.",// msg 
        `OVL_COVER_DEFAULT,        // coverage_level 
        `OVL_POSEDGE,            // clock_edge 
        `OVL_ACTIVE_LOW,        // reset_polarity 
        `OVL_GATE_CLOCK            // gating_type
    ) wd_sig_wready_assert (
        ACLK,                      // clock 
        ARESETN,                // reset
        1'b1,                    // enable
        S_AXI_WVALID==1'b1 && S_AXI_WLAST==1'b1 && S_AXI_WREADY==1'b1,     // start_event 
        S_AXI_WREADY,            // test_expr 
        fire_ar_hcheck            // fire    
    );
    
    // Read, S_AXI_RREADY がアサートされるときは、 S_AXI_RVALID, S_AXI_RREADY, S_AXI_RLAST はアサートされない
    ovl_never #(
        `OVL_ERROR,                // severity_level
        `OVL_ASSERT,            // property_type
        "Read, Assert Error of S_AXI_RREADY",
        `OVL_COVER_DEFAULT,        // coverage_level
        `OVL_POSEDGE,            // clock edge
        `OVL_ACTIVE_LOW,        // reset_polarity
        `OVL_GATE_CLOCK            // gating_type
    ) ar_never_assert (
        ACLK,                    // clock_edge
        ARESETN,                // reset
        1'b1,                    // enable
        S_AXI_ARREADY & (S_AXI_RVALID | S_AXI_RREADY | S_AXI_RLAST),
        fire_ar_never
    );
    
    // Write の転送数をカウントして、 S_AXI_WLAST の出力を確認するアサーション
    always @(posedge ACLK) begin
        if (ARESETN == 1'b0)
            countw <= 0;
        else begin
            if (S_AXI_AWVALID & S_AXI_AWREADY) begin // countw へロード
                countw <= S_AXI_AWLEN;
            end else if (S_AXI_WVALID & S_AXI_WREADY) begin // データ転送
                if (countw==0) begin // データ転送終了
                    if (~S_AXI_WLAST) begin // countw==0 でS_AXI_WLASTが立たない
                        $display("%m: at time %t Error: countw==0 でS_AXI_WLASTが立たない",$time);
                    end
                end
            end
        end
    end
    
    // Read の転送数をカウントして、 S_AXI_RLAST の出力を確認するアサーション
    always @(posedge ACLK) begin
        if (ARESETN == 1'b0)
            countr <= 0;
        else begin
            if (S_AXI_ARVALID & S_AXI_ARREADY) begin // countw へロード
                countr <= S_AXI_ARLEN;
            end else if (S_AXI_RVALID & S_AXI_RREADY) begin // データ転送
                if (countr==0) begin // データ転送終了
                    if (~S_AXI_RLAST) begin // countw==0 でS_AXI_WLASTが立たない
                        $display("%m: at time %t Error: countr==0 でS_AXI_WLASTが立たない",$time);
                    end
                end
            end
        end
    end
    
    // Write 動作用ステートマシン
    always @(posedge ACLK) begin
        if (ARESETN == 1'b0)
            wr_tran_cs <= idle_wts;
        else begin
            case (wr_tran_cs)
                idle_wts :
                    if (S_AXI_AWREADY & (S_AXI_BREADY)) // エラー
                        $display("%m: at time %t S_AXI_AWREADY がアサートされた時に、BREADY信号がアサートされた",$time);
                    else if (S_AXI_AWVALID & S_AXI_AWREADY) // アドレス転送終了
                        wr_tran_cs <= wr_data_tran;
                wr_data_tran :
                    if (S_AXI_BREADY) // エラー
                        $display("%m: at time %t Write データ転送中に、S_AXI_BREADY がアサートされた",$time);
                    else if (S_AXI_WVALID & S_AXI_WREADY & S_AXI_WLAST) // データ転送終了
                        wr_tran_cs <= wr_resp_tran;
                wr_resp_tran :
                    if (S_AXI_WVALID | S_AXI_WREADY | S_AXI_WLAST) // エラー 2013/06/28: S_AXI_AWREADY を条件から削除した
                        $display("%m: at time %t Write Response Channel 転送時に関連しない信号がアサートされた",$time);
                    else if (S_AXI_BVALID & S_AXI_BREADY) // Write Response Channel 転送終了
                        wr_tran_cs <= idle_wts;
            endcase
        end
    end
    
    // Read 動作用ステートマシン
    always @(posedge ACLK) begin
        if (ARESETN == 1'b0)
            rd_trans_cs <= idle_rts;
        else begin
            case (rd_trans_cs)
                idle_rts :
                    if (S_AXI_ARREADY & (S_AXI_RVALID | S_AXI_RREADY | S_AXI_RLAST)) // エラー
                        $display("%m: at time %t S_AXI_ARREADY がアサートされた時に、その他のVALID, READY信号がアサートされた",$time);
                    else if (S_AXI_ARVALID & S_AXI_ARREADY) // アドレス転送終了
                        rd_trans_cs <= rd_data_tran;
                rd_data_tran :
                    if (S_AXI_ARREADY) // エラー
                        $display("%m: at time %t Read データ転送中に、S_AXI_ARREADY がアサートされた",$time);
                    else if (S_AXI_RVALID & S_AXI_RREADY & S_AXI_RLAST) // データ転送終了
                        rd_trans_cs <= idle_rts;
            endcase
        end
    end
                        
endmodule    

`default_nettype wire

  1. 2013年07月03日 04:24 |
  2. ZedBoard
  3. | トラックバック:0
  4. | コメント:5