mti_SetVarValue()

Model Technology Inc.

mti_SetVarValue()

Sets the value of a VHDL variable.

Syntax

mti_SetVarValue( variable_id, value )

Returns

Nothing

Arguments


Name	Type	Description
variable_id	mtiVariableIdT	A handle to a VHDL variable
value	long/void *	For a variable of scalar type, the value to be set; for a variable of real, time, or array type, a pointer to the value to be set

Description

mti_SetVarValue() sets the specified VHDL variable to the specified value immediately. If the variable is of type array, real, or time, then the value type is considered to be "void *" instead of "long".

mti_SetVarValue() cannot be used to set the value of a variable of type record, but it can be used to set the values of the individual scalar or array subelements.

Related functions

None

Example

FLI code

#include <mti.h>

typedef struct varInfoT_tag {
  struct varInfoT_tag  * next;
  char                 * name;
  mtiVariableIdT         varid;
  mtiTypeIdT             typeid;
} varInfoT;

typedef struct {
  varInfoT      * var_info;     /* List of variables. */
  mtiProcessIdT   proc;         /* Test process id. */
} instanceInfoT;

static void setVarValue( mtiVariableIdT varid, mtiTypeIdT vartype )
{
  switch ( mti_GetTypeKind( vartype ) ) {
    case MTI_TYPE_ENUM:
      {
        mtiInt32T scalar_val;
        scalar_val = mti_GetVarValue( varid );
        scalar_val++;
        if (( scalar_val < mti_TickLow( vartype )) ||
          ( scalar_val > mti_TickHigh( vartype ))) {
          scalar_val = mti_TickLeft( vartype );
        }
        mti_SetVarValue( varid, (long)scalar_val );
      }
      break;
    case MTI_TYPE_PHYSICAL:
    case MTI_TYPE_SCALAR:
      {
        mtiInt32T scalar_val;
        scalar_val = mti_GetVarValue( varid );
        scalar_val++;
        mti_SetVarValue( varid, (long)scalar_val );
      }
      break;
    case MTI_TYPE_ARRAY:
      {
        int              i;
        mtiTypeIdT       elem_type;
        mtiVariableIdT * elem_list;
        elem_type = mti_GetArrayElementType( vartype );
        switch ( mti_GetTypeKind( elem_type ) ) {
          case MTI_TYPE_SCALAR:
          case MTI_TYPE_PHYSICAL:
            {
              mtiInt32T * array_val = mti_GetArrayVarValue( varid, 0 );
              for ( i = 0; i < mti_TickLength( vartype ); i++ ) {
                  array_val[i]++;
              }
              mti_SetVarValue( varid, (long)array_val );
            }
            break;
          case MTI_TYPE_ARRAY:
          case MTI_TYPE_RECORD:
          default:
            elem_list = mti_GetVarSubelements( varid, 0 );
            for ( i = 0; i < mti_TickLength( vartype ); i++ ) {
              setVarValue( elem_list[i], mti_GetVarType( elem_list[i] ));
            }
            mti_VsimFree( elem_list );
            break;
          case MTI_TYPE_ENUM:
            if ( mti_TickLength( elem_type ) <= 256 ) {
              char * array_val = mti_GetArrayVarValue( varid, 0 );
              for ( i = 0; i < mti_TickLength( vartype ); i++ ) {
                array_val[i]++;
                if (( array_val[i] < mti_TickLow( elem_type )) ||
                  ( array_val[i] > mti_TickHigh( elem_type ))) {
                  array_val[i] = mti_TickLeft( elem_type );
                }
              }
              mti_SetVarValue( varid, (long)array_val );
            } else {
              mtiInt32T * array_val = mti_GetArrayVarValue( varid, 0 );
              for ( i = 0; i < mti_TickLength( vartype ); i++ ) {
                array_val[i]++;
                if (( array_val[i] < mti_TickLow( elem_type )) ||
                  ( array_val[i] > mti_TickHigh( elem_type ))) {
                  array_val[i] = mti_TickLeft( elem_type );
                }
              }
              mti_SetVarValue( varid, (long)array_val );
            }
            break;
          case MTI_TYPE_REAL:
            {
              double * array_val = mti_GetArrayVarValue( varid, 0 );
              for ( i = 0; i < mti_TickLength( vartype ); i++ ) {
                array_val[i] = array_val[i] + 1.1;
              }
              mti_SetVarValue( varid, (long)array_val );
            }
            break;
          case MTI_TYPE_TIME:
            {
              mtiTime64T * array_val = mti_GetArrayVarValue( varid, 0 );
              for ( i = 0; i < mti_TickLength( vartype ); i++ ) {
                MTI_TIME64_ASGN( array_val[i],
                                MTI_TIME64_HI32(array_val[i]),
                                MTI_TIME64_LO32(array_val[i]) + 1 );
              }
              mti_SetVarValue( varid, (long)array_val );
            }
            break;
          }
      }
      break;
    case MTI_TYPE_RECORD:
      {
        int              i;
        mtiVariableIdT * elem_list;
        elem_list = mti_GetVarSubelements( varid, 0 );
        for ( i = 0; i < mti_TickLength( vartype ); i++ ) {
          setVarValue( elem_list[i], mti_GetVarType( elem_list[i] ));
        }
        mti_VsimFree( elem_list );
      }
      break;
    case MTI_TYPE_REAL:
      {
        double real_val;
        mti_GetVarValueIndirect( varid, &real_val );
        real_val += 1.1;
        mti_SetVarValue( varid, (long)(&real_val) );
      }
      break;
    case MTI_TYPE_TIME:
      {
        mtiTime64T time_val;
        mti_GetVarValueIndirect( varid, &time_val );
        MTI_TIME64_ASGN( time_val, MTI_TIME64_HI32(time_val),
                        MTI_TIME64_LO32(time_val) + 1 );
        mti_SetVarValue( varid, (long)(&time_val) );
      }
      break;
    default:
      break;
  }
}

static void checkValues( void *inst_info )
{
  instanceInfoT *inst_data = (instanceInfoT *)inst_info;
  varInfoT      *varinfo;

  mti_PrintFormatted( "Time [%d,%d]:\n", mti_NowUpper(), mti_Now() );

  for ( varinfo = inst_data->var_info; varinfo; varinfo = varinfo->next ) {
    mti_PrintFormatted( "  Variable %s = %s:\n", varinfo->name,
                       mti_GetVarImageById( varinfo->varid ));
    setVarValue( varinfo->varid, varinfo->typeid );
  }

  mti_ScheduleWakeup( inst_data->proc, 5 );
}

static varInfoT * setupVariable( mtiVariableIdT varid )
{
  varInfoT * varinfo;

  varinfo          = (varInfoT *) mti_Malloc( sizeof(varInfoT) );
  varinfo->varid   = varid;
  varinfo->name    = mti_GetVarName( varid );
  varinfo->typeid  = mti_GetVarType( varid );
  varinfo->next    = 0;

  return( varinfo );
}

static void initInstance( void )
{
  instanceInfoT * inst_data;
  mtiProcessIdT   procid;
  mtiVariableIdT  varid;
  varInfoT      * curr_info;
  varInfoT      * varinfo;

  inst_data           = mti_Malloc( sizeof(instanceInfoT) );
  inst_data->var_info = 0;

  for ( procid = mti_FirstProcess( mti_GetTopRegion() );
        procid; procid = mti_NextProcess() ) {
    for ( varid = mti_FirstVar( procid ); varid; varid = mti_NextVar() ) {
      varinfo = setupVariable( varid );
      if ( inst_data->var_info == 0 ) {
        inst_data->var_info = varinfo;
      }
      else {
        curr_info->next = varinfo;
      }
      curr_info = varinfo;
    }
  }

  inst_data->proc = mti_CreateProcess( "Test Process", checkValues,
                                      (void *)inst_data );
  mti_ScheduleWakeup( inst_data->proc, 5 );
}

void initForeign(
  mtiRegionIdT       region,   /* The ID of the region in which this     */
                               /* foreign architecture is instantiated.  */
  char              *param,    /* The last part of the string in the     */
                               /* foreign attribute.                     */
  mtiInterfaceListT *generics, /* A list of generics for the foreign model.*/
  mtiInterfaceListT *ports     /* A list of ports for the foreign model.   */
)
{
  mti_AddLoadDoneCB( initInstance, 0 );
}

HDL code

entity for_model is
end for_model;

architecture a of for_model is
  attribute foreign of a : architecture is "initForeign for_model.sl;";
begin
end a;

library ieee;
use ieee.std_logic_1164.all;

entity top is

  type bitarray  is array( 3 downto 0 ) of bit;
  type intarray  is array( 1 to 3 )     of integer;
  type realarray is array( 1 to 2 )     of real;
  type timearray is array( -1 to 0 )    of time;

  type rectype is record
    a : bit;
    b : integer;
    c : real;
    d : std_logic;
    e : bitarray;
  end record;

end top;

architecture a of top is

  component for_model
  end component;

  for all : for_model use entity work.for_model(a);

begin

  inst1 : for_model;

  p1 : process

    variable bitsig      : bit       := '1';
    variable intsig      : integer   := 21;
    variable realsig     : real      := 16.35;
    variable timesig     : time      := 5 ns;
    variable stdlogicsig : std_logic := 'H';

    variable bitarr      : bitarray  := "0110";
    variable stdlogicarr : std_logic_vector( 1 to 4 ) := "01LH";
    variable intarr      : intarray  := ( 10, 11, 12 );
    variable realarr     : realarray := ( 11.6, 101.22 );
    variable timearr     : timearray := ( 15 ns, 6 ns );

    variable rec         : rectype   := ( '0', 1, 3.7, 'H', "1001" );

  begin

    wait;

  end process;

end a;

Simulation output

% vsim -c top
Reading .../modeltech/sunos5/../tcl/vsim/pref.tcl 

# 5.4b

# vsim -c top 
# Loading .../modeltech/sunos5/../std.standard
# Loading .../modeltech/sunos5/../ieee.std_logic_1164(body)
# Loading work.top(a)
# Loading work.for_model(a)
# Loading ./for_model.sl
VSIM 1> run 15
# Time [0,5]:
#   Variable bitsig = '1':
#   Variable intsig = 21:
#   Variable realsig = 16.35:
#   Variable timesig = 5 ns:
#   Variable stdlogicsig = 'H':
#   Variable bitarr = "0110":
#   Variable stdlogicarr = "01LH":
#   Variable intarr = {10} {11} {12}:
#   Variable realarr = {11.6} {101.22}:
#   Variable timearr = {15 ns} {6 ns}:
#   Variable rec = {'0'} {1} {3.7} {'H'} {"1001"}:
# Time [0,10]:
#   Variable bitsig = '0':
#   Variable intsig = 22:
#   Variable realsig = 17.45:
#   Variable timesig = 6 ns:
#   Variable stdlogicsig = '-':
#   Variable bitarr = "1001":
#   Variable stdlogicarr = "1ZH-":
#   Variable intarr = {11} {12} {13}:
#   Variable realarr = {12.7} {102.32}:
#   Variable timearr = {16 ns} {7 ns}:
#   Variable rec = {'1'} {2} {4.8} {'-'} {"0110"}:
# Time [0,15]:
#   Variable bitsig = '1':
#   Variable intsig = 23:
#   Variable realsig = 18.55:
#   Variable timesig = 7 ns:
#   Variable stdlogicsig = 'U':
#   Variable bitarr = "0110":
#   Variable stdlogicarr = "ZW-U":
#   Variable intarr = {12} {13} {14}:
#   Variable realarr = {13.8} {103.42}:
#   Variable timearr = {17 ns} {8 ns}:
#   Variable rec = {'0'} {3} {5.9} {'U'} {"1001"}:
VSIM 2> quit

Model Technology Inc.
Voice: (503) 641-1340
Fax: (503)526-5410
http://www.model.com
sales@model.com