動作解説

本コードは４ビットｘ４ビット＝８ビットの乗算回路を行います．
乗算回路はモジュール名：func_seq_testであり，Mult制御信号が有効になると動作します．
Mult信号の有効により，以下の動作が順に実行されます．
　　１．func Mult seq {…} が呼び出されます．
　　２．１．内でfunc_selfで定義されたexec_mult()機能が呼び出されます．
　　３．exec_mult()では，8ビットのtemp_resultレジスタに乗算結果が入ります．
　　４．temp_resultの値はQout出力端子に反映されます．
　　５．Comp()制御出力信号を駆動して終了します．

この動作では，Comp()はMult()が入力されてから１クロック後に駆動されます．
func Mult seq{…}の中では，Comp()の位置によりMult()入力後にComp()が
駆動されるタイミングが変わりますので，注意してください．

利用構文/キーワード：

・func_in 制御入力信号
・func_out 制御出力信号
・func_self 内部制御名
・func 制御入力信号 seq { … }

NSL記述例

/* ************************************************************ */
declare func_seq_test {
    input       Ain[4] ;
    input       Bin[4] ;
    output      Qout[8] ;

    func_in Mult( Ain, Bin ) ;
        // Mult:Control input signal. Request for execute a multiply operation.
    func_out    Comp( Qout ) ;
        // Comp:Control output signal. Indicates multiply operation is finished.
}

/* ************************************************************ */
/* ************************************************************ */

module  func_seq_test {

    reg         temp_result[8] = 8'h00 ;    // Define registerd signal
                        //      A registerd signal can assing initial value.
//  wire        temp_result[8] ;            // Define wired signal
                        //      A wired signal does not need initial value.

// Declare internal control function for multiply operation
    func_self   exec_mult() ;   // func_self [Name of internal control func]

// Equation of sequential operation machine
    function    Mult    seq {
    // 0 clock
        exec_mult() ;                       // Launch internal control function
    // 1 clock
        {
            Qout = temp_result[7:0] ;       // Data out via output pin
            Comp() ;        // Drive a control output signal of 'Comp()' pin.
        }
    }

// Equation of multiply function
    function    exec_mult {
        temp_result := Ain[3:0] * Bin[3:0] ;    // Operation : register mode.
//      temp_result = Ain[3:0] * Bin[3:0] ;     // Operation : wire mode.
    }

}       // End of module

/*
    Upper module : Instanciate 'func_seq_test'
*/
/* ************************************************************ */
/* ************************************************************ */
/* ************************************************************ */
declare     top {
    input       a[4] ;          // Data-bus a[3:0]
    input       b[4] ;          // Data-bus b[3:0]

    output      q[8] ;

    func_in go ;            // Control input signal.
}

module  top {
    func_seq_test   DUT ;
                    // Instanciate a 'func_seq' module as name of 'DUT'.

// Define two-parameter for multiply module
    function    go  {
        DUT.Mult( Ain = a, Bin = b ) ;
    }

// Data out at control output signal of 'DUT.comp' will be asserted.
    function    DUT.Comp    {
        q = DUT.Qout ;
    }

}

Verilog変換例

/*
 Produced by NSL Core, IP ARCH, Inc. Fri Jun 04 17:54:19 2010

 Licensed to :EVALUATION USER:
*/

module func_seq_test ( p_reset , m_clock , Ain , Bin , Qout , Mult , Comp );
  input p_reset, m_clock;
  input [3:0] Ain;
  input [3:0] Bin;
  output [7:0] Qout;
  input Mult;
  output Comp;
  reg [7:0] temp_result;
  wire exec_mult;
  reg _reg_0;
  reg _reg_1;

   assign  exec_mult = Mult|_reg_1;
   assign  Qout =
//synthesis translate_off
(_reg_0)?
//synthesis translate_on
((_reg_0)?temp_result[7:0]:8'b0)
//synthesis translate_off
:8'bx
//synthesis translate_on
;
   assign  Comp = _reg_0;
always @(posedge m_clock or posedge p_reset)
  begin
if (p_reset)
     temp_result <= 8'b00000000;
else if (exec_mult)
      temp_result <= (Ain[3:0])*(Bin[3:0]);
end
always @(posedge m_clock or posedge p_reset)
  begin
if (p_reset)
     _reg_0 <= 1'b0;
else if (Mult|_reg_0|_reg_1)
      _reg_0 <= _reg_1|Mult;
end
always @(posedge m_clock or posedge p_reset)
  begin
if (p_reset)
     _reg_1 <= 1'b0;
else if (_reg_1)
      _reg_1 <= 1'b0;
end
endmodule
/*
 Produced by NSL Core, IP ARCH, Inc. Fri Jun 04 17:54:19 2010

 Licensed to
*/

module top ( p_reset , m_clock , a , b , q , go );
  input p_reset, m_clock;
  input [3:0] a;
  input [3:0] b;
  output [7:0] q;
  input go;
  wire _DUT_Comp;
  wire _DUT_Mult;
  wire [7:0] _DUT_Qout;
  wire [3:0] _DUT_Bin;
  wire [3:0] _DUT_Ain;
func_seq_test DUT (.p_reset(p_reset), .m_clock(m_clock), .Comp(_DUT_Comp), .Mult(_DUT_Mult), .Qout(_DUT_Qout), .Bin(_DUT_Bin), .Ain(_DUT_Ain));

   assign  _DUT_Mult = go;
   assign  _DUT_Bin =
//synthesis translate_off
(go)?
//synthesis translate_on
((go)?b:4'b0)
//synthesis translate_off
:4'bx
//synthesis translate_on
;
   assign  _DUT_Ain =
//synthesis translate_off
(go)?
//synthesis translate_on
((go)?a:4'b0)
//synthesis translate_off
:4'bx
//synthesis translate_on
;
   assign  q =
//synthesis translate_off
(_DUT_Comp)?
//synthesis translate_on
((_DUT_Comp)?_DUT_Qout:8'b0)
//synthesis translate_off
:8'bx
//synthesis translate_on
;
endmodule
/*
 Produced by NSL Core, IP ARCH, Inc. Fri Jun 04 17:54:19 2010

 Licensed to
*/