言語/verilog/Tips/非同期乗換え：バス1 - MoriLab.

非同期乗換え：バス1

非同期乗換え：バス1

概要

バスの乗り換え
(詳細記述予定)

動作確認

ツール	バージョン	結果
ncverilog		未確認
VCS-MX		未確認
ModelSim		未確認

テストコード

(記述予定)

// ----------------------------------------------------------------------------
// main Operation Setting
// ----------------------------------------------------------------------------
reg [7:0] value;
initial begin
  wait(CHECK_START);
  @(posedge CLKIN);
 
  for(i=0;i<1000;i=i+1)begin
    wait(READY);
    value = $random;
    DIEN  <= #DLY 1;
    DI    <= #DLY value;
	@(posedge CLKIN);
    DIEN  <= #DLY 0;
    DI    <= #DLY 'bx;
 
    while(!READY) @(posedge CLKIN);
 
  end
 
  $display("");
  $display("NOTE    : [%m] Main Task is completed. -- %t", $time);
  TASKS[0] = 1'b1;
end
 
// -------------------------------------------------------------------------------
// Output Compare Operation Setting
// -------------------------------------------------------------------------------
initial begin
  wait(CHECK_START);
  ref_DOEN = 0;
  for(j=0;j<1000;j=j+1)begin
    wait(DOEN);
    ref_DOEN = 1;
    ref_DO   = value;
    @(posedge CLKOT);
    ref_DOEN = 0;
    ref_DO   = 0;
    @(posedge CLKOT);
  end
 
 
  $display("");
  $display("NOTE    : [%m] Output Compare Task is completed. -- %t", $time);
  TASKS[1] = 1'b1;
end

ソースコード

(記述予定)

ASYNC_BUS

module ASYNC_BUS(
    CLKIN       ,
    CLKOT       ,
    RST_X       ,
    DIEN        ,
    DI          ,
    READY       ,
    DOEN        ,
    DO          
);
// Parameter                                                                    //
    parameter            P_WIDTH = 8; // P   : data bus width                     
// Port                                                                         //
    input                CLKIN;       // C   : Clock                              
    input                CLKOT;       // C   : Clock                              
    input                RST_X;       // R   : Reset                              
    input                DIEN;        // I   : Data in enable                     
    input  [P_WIDTH-1:0] DI;          // I   : Data in                            
    output               READY;       // O   : ready                              
    output               DOEN;        // O   : Data out enable                    
    output [P_WIDTH-1:0] DO;          // O   : Data out                           
 
//////////////////////////////////////////////////////////////////////////////////
// net                                                                          //
//////////////////////////////////////////////////////////////////////////////////
 
    // Input port                                                               //
    wire   [P_WIDTH-1:0] w_dat;               // 
    wire                 w_ack;               // 
 
//******************************************************************************//
// RTL                                                                          //
//******************************************************************************//
 
// Parameter                                                                    //
 
    // simulation Parameter                                                     //
    parameter DLY               = 1;        // cell delay                         
 
//////////////////////////////////////////////////////////////////////////////////
// Instance                                                                     //
//////////////////////////////////////////////////////////////////////////////////
 
ASYNC_BUS_TRN #(
    P_WIDTH         // WIDTH
)
u_async_bus_trn (
    .CLK     (CLKIN  ),
    .RST_X   (RST_X  ),
    .DEN     (DIEN   ),
    .DI      (DI     ),
    .ACK     (w_ack  ),
    .REQ     (w_req  ),
    .READY   (READY  ),
    .DO      (w_dat  )
);
 
ASYNC_BUS_RCV #(
    P_WIDTH         // WIDTH
)
u_async_bus_rcv (
    .CLK    (CLKOT  ),
    .RST_X  (RST_X  ),
    .REQ    (w_req  ),
    .DI     (w_dat  ),
    .DEN    (DOEN   ),
    .DO     (DO     ),
    .ACK    (w_ack  )
);
 
endmodule

ASYNC_BUS_RCV

module ASYNC_BUS_RCV(
    CLK    ,
    RST_X  ,
    REQ    ,
    DI     ,
    DEN    ,
    DO     ,
    ACK    
);
// parameter                                                                    //
    parameter            P_WIDTH      = 8;    // P   : data bus width             
// Port                                                                         //
    input                CLK;                 // C   : Clock                      
    input                RST_X;               // R   : Reset                      
    input                REQ;                 // I   : Request                    
    input  [P_WIDTH-1:0] DI;                  // I   : Data in                    
    output               DEN;                 // O   : Data enable                
    output [P_WIDTH-1:0] DO;                  // O   : Data out                   
    output               ACK;                 // O   : Ack                        
 
//////////////////////////////////////////////////////////////////////////////////
// Register                                                                     //
//////////////////////////////////////////////////////////////////////////////////
 
    // Async Buffer                                                             //
    reg                  r_req_1d;            //                                  
    reg                  r_req_2d;            //                                  
    // Output Port                                                              //
    reg                  r_den;               //                                  
    reg    [P_WIDTH-1:0] r_do;                //                                  
    reg                  r_ack;               //                                  
 
    // state machine                                                            //
    reg    [1:0]         r_async_st;          //                                  
 
//////////////////////////////////////////////////////////////////////////////////
// net                                                                          //
//////////////////////////////////////////////////////////////////////////////////
 
    // Input Port                                                               //
    wire                 w_req;               //                                  
    wire   [P_WIDTH-1:0] w_di;                //                                  
    // state machine                                                            //
    reg    [1:0]         w_async_st;          //                                  
 
//******************************************************************************//
// RTL                                                                          //
//******************************************************************************//
 
// Parameter                                                                    //
 
    // simulation Parameter                                                     //
    parameter DLY               = 1;        // cell delay                         
    // parameter                                                                //
    // state machine                                                            //
    parameter ST_IDLE           = 2'b00;    //                                    
    parameter ST_ACK            = 2'b01;    //                                    
    parameter ST_OUT            = 2'b10;    //                                    
 
// connect Input Port                                                           //
    assign w_req                = REQ;      //                                    
    assign w_di                 = DI;       //                                    
 
// connect Output Port                                                          //
    assign DEN                  = r_den;    //                                    
    assign DO                   = r_do;     //                                    
    assign ACK                  = r_ack;    //                                    
 
 
  //----------------------------------------------------------------------------//
 // State machine                                                              //
//----------------------------------------------------------------------------//
 
    // DFF                                                          //
    always @ (posedge CLK or negedge RST_X) begin
        if (~RST_X) begin
            r_async_st <= #DLY ST_IDLE;
        end else begin
            r_async_st <= #DLY w_async_st;
        end
    end
 
    // Gate                                                         //
    always @ (r_async_st or r_req_2d) begin
        case(r_async_st)
            // idle                                     //
            ST_IDLE : begin
                if(r_req_2d)begin
                    w_async_st <= ST_ACK;
                end else begin
                    w_async_st <= ST_IDLE;
                end
            end
            // send ack                                 //
            ST_ACK  : begin
                if(~r_req_2d)begin
                    w_async_st <= ST_OUT;
                end else begin
                    w_async_st <= ST_ACK;
                end
            end
            //  request                                 //
            ST_OUT  : begin
                w_async_st <= ST_IDLE;
            end
            // illigal state.                           //
            default : begin
                w_async_st <= ST_IDLE;
            end
        endcase
    end
 
    // ACK                                                     //
    always @ (posedge CLK or negedge RST_X) begin
        if (~RST_X) begin
            r_ack <= #DLY 1'b0;
        end else begin
            if(w_async_st==ST_ACK)begin
                r_ack <= #DLY 1'b1;
            end else begin
                r_ack <= #DLY 1'b0;
            end
        end
    end
 
    // Data & Enable                                           //
    always @ (posedge CLK or negedge RST_X) begin
        if (~RST_X) begin
            r_den <= #DLY 1'd0;
            r_do  <= #DLY {P_WIDTH{1'b0}};
        end else begin
            if(w_async_st==ST_OUT)begin
                r_den <= #DLY 1'b1;
                r_do  <= #DLY w_di;
            end else begin
                r_den <= #DLY 1'b0;
                r_do  <= #DLY {P_WIDTH{1'b0}};
            end
        end
    end
 
//////////////////////////////////////////////////////////////////////////////////
// Async Buffer                                                                 //
//////////////////////////////////////////////////////////////////////////////////
    always @ (posedge CLK or negedge RST_X) begin
        if (~RST_X) begin
            r_req_1d<= #DLY 1'd0;
            r_req_2d<= #DLY 1'd0;
        end else begin
            r_req_1d<= #DLY w_req;
            r_req_2d<= #DLY r_req_1d;
        end
    end
 
endmodule

ASYNC_BUS_TRN

module ASYNC_BUS_TRN(
    CLK     ,
    RST_X   ,
    DEN     ,
    DI      ,
    ACK     ,
    REQ     ,
    DO      ,
    READY
);
// parameter                                                                    //
    parameter            P_WIDTH = 8; // P   : data bus width                     
// Port                                                                         //
    input                CLK;         // C   : Clock                              
    input                RST_X;       // R   : Reset                              
    input                DEN;         // I   : Data enable                        
    input  [P_WIDTH-1:0] DI;          // I   : Data in                            
    input                ACK;         // I   : ack                                
    output               REQ;         // O   : request                            
    output [P_WIDTH-1:0] DO;          // O   : Data out                           
    output               READY;       // O   : ready                              
 
//////////////////////////////////////////////////////////////////////////////////
// Register                                                                     //
//////////////////////////////////////////////////////////////////////////////////
 
    // Async Buffer                                                             //
    reg                  r_ack_1d;            // 
    reg                  r_ack_2d;            // 
    // output buffer                                                            //
    reg                  r_req;               // 
    reg    [P_WIDTH-1:0] r_do;                // 
    // state machine                                                            //
    reg    [1:0]         r_async_st;          // 
 
//////////////////////////////////////////////////////////////////////////////////
// net                                                                          //
//////////////////////////////////////////////////////////////////////////////////
 
    // Input port                                                               //
    wire                 w_den;               // 
    wire   [P_WIDTH-1:0] w_di;                // 
    wire                 w_ack;               // 
    // Output port                                                               //
    wire                 w_ready;             // 
 
    // state machine                                                            //
    reg    [1:0]         w_async_st;          // 
 
//******************************************************************************//
// RTL                                                                          //
//******************************************************************************//
 
// Parameter                                                                    //
    // simulation Parameter                                                     //
    parameter DLY               = 1;        // cell delay                         
    // state machine                                                            //
    parameter ST_IDLE           = 2'b00;    //                                    
    parameter ST_REQ            = 2'b01;    //                                    
    parameter ST_ACK            = 2'b10;    //                                    
 
// External pin                                                                 //
    // connect Input Port                                                       //
    assign w_den    = DEN;                  //                                    
    assign w_di     = DI;                   //                                    
    assign w_ack    = ACK;                  //                                    
    // connect Output Port                                                      //
    assign REQ      = r_req;                //                                    
    assign DO       = r_do;                 //                                    
    assign READY    = w_ready;              //                                    
 
  //----------------------------------------------------------------------------//
 // State Machine                                                              //
//----------------------------------------------------------------------------//
 
    // DFF                                                          //
    always @ (posedge CLK or negedge RST_X) begin
        if (~RST_X) begin
            r_async_st <= #DLY ST_IDLE;
        end else begin
            r_async_st <= #DLY w_async_st;
        end
    end
 
    // Gate                                                         //
    always @ (r_async_st or w_den or r_ack_2d) begin
        case(r_async_st)
            // idle                                     //
            ST_IDLE : begin
                if(w_den)begin
                    w_async_st <= ST_REQ;
                end else begin
                    w_async_st <= ST_IDLE;
                end
            end
            // send request                             //
            ST_REQ  : begin
                if(r_ack_2d)begin
                    w_async_st <= ST_ACK;
                end else begin
                    w_async_st <= ST_REQ;
                end
            end
            // wait until finished ack                  //
            ST_ACK  : begin
                if(~r_ack_2d)begin
                    w_async_st <= ST_IDLE;
                end else begin
                    w_async_st <= ST_ACK;
                end
            end
            // illigal state.                           //
            default : begin
                w_async_st <= ST_IDLE;
            end
        endcase
    end
 
  //----------------------------------------------------------------------------//
 // Output                                                                     //
//----------------------------------------------------------------------------//
 
    // REQ                                                     //
    always @ (posedge CLK or negedge RST_X) begin
        if (~RST_X) begin
            r_req <= #DLY 1'b0;
        end else begin
            if(w_async_st==ST_REQ)begin
                r_req <= #DLY 1'b1;
            end else begin
                r_req <= #DLY 1'b0;
            end
        end
    end
 
    // Data                                                    //
    always @ (posedge CLK or negedge RST_X) begin
        if (~RST_X) begin
            r_do <= #DLY {P_WIDTH{1'b0}};
        end else begin
            if(w_den & r_async_st==ST_IDLE)begin
                r_do <= #DLY w_di;
            end
        end
    end
 
    // READY                                                   //
    assign w_ready = ~( w_den | r_req | r_ack_2d);
 
//////////////////////////////////////////////////////////////////////////////////
// Async Buffer                                                                 //
//////////////////////////////////////////////////////////////////////////////////
 
    always @ (posedge CLK or negedge RST_X) begin
        if (~RST_X) begin
            r_ack_1d    <= #DLY  1'd0;
            r_ack_2d    <= #DLY  1'd0;
        end else begin
            r_ack_1d    <= #DLY w_ack;
            r_ack_2d    <= #DLY r_ack_1d;
        end
    end
 
endmodule

「非同期乗換え：バス1」をウィキ内検索

最終更新：2008年11月21日 11:56

MoriLab.

言語 > verilog > Tips > 非同期乗換え：バス1

トップページ

更新履歴

非同期乗換え：バス1

概要

動作確認

テストコード

ソースコード