Académique Documents
Professionnel Documents
Culture Documents
/************************************************** ******************/
/***** *****/
/***** L A B C E N T E R E L E C T R O N I C S *****/
/***** *****/
/***** LABCENTER INTEGRATED SIMULATION ARCHITECTURE *****/
/***** *****/
/***** Virtual System Modeling Interface Header *****/
/***** *****/
/************************************************** ******************/
/************************************************** ******************/
#ifndef VSM_HPP
#define VSM_HPP
//
//
//
//
//
//
//
//
//
//
//
//
#ifdef __SC__
typedef long long LONGLONG;
#else
typedef __int64 LONGLONG;
#endif
#ifndef
typedef
typedef
typedef
typedef
typedef
typedef
#endif
_WINDOWS_
VOID *HANDLE;
VOID *HWND;
VOID *HDC;
unsigned WPARAM;
long LPARAM;
long LRESULT;
#endif
// Text
#define
#define
#define
#define
#define
#define
justifications:
TXJ_LEFT 0
TXJ_RIGHT 1
TXJ_CENTRE 2
TXJ_BOTTOM 0
TXJ_TOP 4
TXJ_MIDDLE 8
output services:
HTEXTSTYLE createtextstyle (CHAR *name=NULL) = 0;
VOID selecttextstyle (HTEXTSTYLE style) = 0;
VOID settextfont (CHAR *name) = 0;
VOID settextsize (INT h) = 0;
VOID setbold (BOOL f) = 0;
VOID setitalic (BOOL f) = 0;
VOID setunderline (BOOL f) = 0;
VOID settextcolour (COLOUR c) = 0;
VOID drawtext (INT x, INT y, INT rot, INT jflags, CHAR *text, ...) = 0;
ACF_MIDDLE = 0x00000004,
ACF_INC = 0x00010000,
ACF_DEC = 0x00020000,
ACF_TOGGLE = 0x00040000
};
// Definition of services that a graphical model must provide to an active compo
nent
class IACTIVEMODEL
{ public:
virtual VOID initialize (ICOMPONENT *cpt) = 0;
virtual ISPICEMODEL *getspicemodel (CHAR *primitive) = 0;
virtual IDSIMMODEL *getdsimmodel (CHAR *primitive) = 0;
virtual VOID plot (ACTIVESTATE state) = 0;
virtual VOID animate (INT element, ACTIVEDATA *newstate) = 0;
virtual BOOL actuate (WORD key, INT x, INT y, DWORD flags) = 0;
};
/************************************************** *******************
***** Generic Simulator Interface ****
**************************************/
// Time
typedef
typedef
typedef
typedef
typedef
type definitions:
DOUBLE REALTIME;
LONGLONG ABSTIME;
const ABSTIME &CREFABSTIME;
LONGLONG RELTIME;
const RELTIME &CREFRELTIME;
class IINSTANCE
{ public:
// Basic property access:
virtual CHAR *id() = 0;
virtual CHAR *value() = 0;
virtual CHAR *getstrval(CHAR *name, CHAR *defval=NULL) = 0;
#ifdef __SC__
virtual DOUBLE getnumval (CHAR *name, DOUBLE defval=0) = 0;
#else
virtual VOID getnumval (DOUBLE *result, CHAR *name, DOUBLE defval=0) = 0;
#endif
virtual BOOL getboolval (CHAR *name, BOOL defval=FALSE) = 0;
virtual DWORD gethexval (CHAR *name, DWORD defval=0) = 0;
virtual LONG getinitval (CHAR *name, LONG defval=0) = 0;
virtual RELTIME getdelay (CHAR *name, RELTIME deftime=0) = 0;
// Special property access
virtual IACTIVEMODEL *getactivemodel() = 0;
virtual IINSTANCE *getinterfacemodel() = 0;
virtual BOOL getmoddata (BYTE **data, DWORD *size) = 0;
// Access to the nodes and pins:
virtual SPICENODE getspicenode (CHAR *namelist, BOOL required) = 0;
virtual IDSIMPIN *getdsimpin (CHAR *namelist, BOOL required) = 0;
// Logging and messaging:
virtual VOID log (CHAR *msg, ...) = 0;
virtual VOID warning (CHAR *msg, ...) = 0;
virtual VOID error (CHAR *msg, ...) = 0;
virtual VOID fatal (CHAR *msg, ...) = 0;
virtual BOOL message (CHAR *msg, ...) = 0;
// Pop-up window support:
virtual IPOPUP *createpopup (CREATEPOPUPSTRUCT *cps) = 0;
virtual VOID deletepopup (POPUPID id) = 0;
// Virtual debug monitor interface:
virtual BOOL setvdmhlr (class ICPU *) = 0;
// Generic memory loader:
virtual BOOL loadmemory (CHAR *filename, VOID *buffer, UINT size, UINT base=0, U
INT shift=0) = 0;
// Access to bus pins
virtual IBUSPIN *getbuspin (CHAR *namestem, UINT base, UINT width, BOOL required
) = 0;
virtual IBUSPIN *getbuspin (CHAR *name, IDSIMPIN **pins, UINT width) = 0;
};
/************************************************** *******************
***** Analogue Modelling Interface ****
***************************************/
typedef DOUBLE SPICEFREQ;
enum SPICEMODES
{ SPICETRAN=0x1,
SPICEAC=0x2,
SPICEDC=0x70,
SPICEDCOP=0x10,
SPICETRANOP=0x20,
SPICEDCTRANCURVE=0x40,
SPICEINITFLOAT=0x100,
SPICEINITJCT=0x200,
SPICEINITFIX=0x400,
SPICEINITSMSIG=0x800,
SPICEINITTRAN=0x1000,
SPICEINITPRED=0x2000,
SPICEUIC=0x10000l
};
enum SPICEVARS
{ SPICETIME,
SPICEOMEGA,
SPICEDELTA,
SPICEGMIN,
SPICEDELMIN,
SPICEMINBREAK,
SPICESRCFACT,
SPICEFINALTIME,
// Conv Tolerances?
};
class ISPICECKT
{ public:
virtual BOOL ismode (SPICEMODES flags) = 0;
#ifdef __SC__
virtual DOUBLE sysvar (SPICEVARS var) = 0;
#else
virtual VOID sysvar (DOUBLE *result, SPICEVARS var) = 0;
#endif
virtual DOUBLE &statevar (INT s, INT n) = 0;
virtual DOUBLE &rhs (SPICENODE n) = 0;
virtual DOUBLE &rhsold (SPICENODE n) = 0;
virtual DOUBLE &irhs (SPICENODE n) = 0;
virtual DOUBLE &irhsold (SPICENODE n) = 0;
virtual SPICENODE getnode (CHAR *netname) = 0;
virtual SPICENODE newvoltnode (CHAR *partid, CHAR *nodename) = 0;
virtual SPICENODE newcurnode (CHAR *partid, CHAR *nodename) = 0;
virtual VOID delnode (SPICENODE node) = 0;
virtual DOUBLE *allocsmp (SPICENODE node1, SPICENODE node2) = 0;
virtual BOOL setbreak (REALTIME time) = 0;
virtual VOID suspend (IINSTANCE *instance, CHAR *msg) = 0;
virtual INT allocvars (INT n) = 0;
virtual VOID integrate (DOUBLE *geq, DOUBLE *ceq, DOUBLE cap, INT statevars) = 0
;
virtual VOID truncerr (INT statevars, DOUBLE *timestep) = 0;
};
class ISPICEMODEL
{ public:
virtual INT isanalog (CHAR *pinname) = 0;
virtual VOID setup (IINSTANCE *, ISPICECKT *) = 0;
virtual VOID runctrl (RUNMODES mode) = 0;
virtual VOID actuate (REALTIME time, ACTIVESTATE newstate) = 0;
virtual BOOL indicate (REALTIME time, ACTIVEDATA *newstate) = 0;
virtual VOID dcload (REALTIME time, SPICEMODES mode, DOUBLE *oldrhs, DOUBLE *new
rhs) = 0;
/************************************************** *******************
***** Digital Modelling Interface ****
**************************************/
// DSIM Type Definitions:
typedef long EVENTID;
#define EID_BREAKPOINT 0x8000000
// Simulator Modes
enum DSIMMODES
{ DSIMBOOT = 0x01,
DSIMSETTLE = 0x02,
DSIMNORMAL = 0x04,
DSIMEND = 0x08
};
enum DSIMVARS
{ DSIMTIMENOW=-1,
DSIMTDSCALE
};
// Pin drive flags
#define DPF_INPUT 0x01
#define DPF_OUTPUT 0x02
#define DPF_BIDIR 0x03
// State polarity bits:
#define SP_UNDEFINED 0x00 // The undefined state.
#define SP_LOW 0x01 // Polarity Low.
#define SP_FLOAT 0x02 // Polarity Float (i.e. half volts).
#define SP_HIGH 0x03 // Polarity High.
#define SP_MASK 0x03 // Use to mask off polarity.
// State strength bits:
#define SS_FLOAT 0x00 // Strength Float.
#define SS_DRIVEN 0x04 // Flag bit for driven state.
#define SS_WEAK 0x04 // Strength Weak.
#define SS_STRONG 0x0C // Strength Strong.
#define SS_INJECT 0x14 // Strength for generators.
#define SS_POWER 0x1C // Strength Power rail.
#define SS_MASK 0x1C // Used to mask off strength.
// State flag bits:
#define SF_CONTENTION 0x20 //
#define SF_MESSAGE 0x40 // Message associated with state (?)
#define SF_MASK 0xE0 // Use to mask off flags.
// State constants:
// Application code should deal only with these values;
// Manipulation of contention and message flags is a kernel function.
enum STATE
{ UNDEFINED = 0,
TSTATE = 1,
FSTATE = -1,
PLO = SS_POWER+SP_LOW,
ILO = SS_INJECT+SP_LOW,
SLO = SS_STRONG+SP_LOW,
WLO = SS_WEAK+SP_LOW,
FLT = SS_FLOAT+SP_FLOAT,
WHI = SS_WEAK+SP_HIGH,
SHI = SS_STRONG+SP_HIGH,
IHI = SS_INJECT+SP_HIGH,
PHI = SS_POWER+SP_HIGH,
WUD = SS_WEAK+SP_UNDEFINED,
SUD = SS_STRONG+SP_UNDEFINED
};
// Functions for testing states.
inline BOOL islow (STATE s) { return (s & SP_MASK) == SP_LOW; }
inline BOOL ishigh (STATE s) { return (s & SP_MASK) == SP_HIGH; }
inline BOOL isfloating (STATE s) { return (s & SP_MASK) == SP_FLOAT; }
inline BOOL iscontention (STATE s) { return s & SF_CONTENTION; }
inline BOOL isdefined (STATE s) { return s != SP_UNDEFINED; }
inline BOOL ishighlow (STATE s) { return s & 1; }
inline INT polarity (STATE s) { return s & SP_MASK; }
inline INT strength (STATE s) { return s & SS_MASK; }
// Type for memory address
typedef DWORD ADDRESS;
// This is declared so we can use pointers to them, but the implementation is no
t exposed:
class EVENT;
class IDSIMMODEL;
// This declares a pointer to a function which a model
// can specify to be called for events on a particular pin or group of pins.
typedef VOID (IDSIMMODEL::*PINHANDLERFN)(ABSTIME time, DSIMMODES mode);
typedef VOID (IDSIMMODEL::*CALLBACKHANDLERFN)(ABSTIME time, EVENTID id);
// Interface to a digital component instance.
class IDSIMCKT
{ public:
#ifdef __SC__
inline ABSTIME systime() { DOUBLE t = sysvar(DSIMTIMENOW); return *(ABSTIME *)&t
; }
virtual DOUBLE sysvar (DSIMVARS var) = 0;
#else
inline VOID systime(ABSTIME *at) { sysvar((DOUBLE *)at, DSIMTIMENOW); }
virtual VOID sysvar (DOUBLE *result, DSIMVARS var) = 0;
#endif
virtual EVENT *setcallback (ABSTIME evttime, IDSIMMODEL *model, EVENTID id) = 0;
virtual BOOL cancelcallback (EVENT *event, IDSIMMODEL *model) = 0;
virtual VOID setbreak (ABSTIME breaktime) = 0;
virtual VOID suspend (IINSTANCE *instance, CHAR *msg) = 0;
virtual EVENT *setcallbackex (ABSTIME evttime, IDSIMMODEL *model, CALLBACKHANDLE
RFN func, EVENTID id) = 0;
virtual DSIMNODE newnode (CHAR *partid, CHAR *nodename) = 0;
virtual IDSIMPIN *newpin (IINSTANCE *, DSIMNODE node, CHAR *name, DWORD flags) =
0;
virtual EVENT *setclockcallback (ABSTIME starttime, RELTIME period, IDSIMMODEL *
model, CALLBACKHANDLERFN func, EVENTID id) = 0;
};
// Classic Interface to a digital pin object.
class IDSIMPIN1
{ public:
virtual BOOL invert() = 0;
virtual STATE istate() = 0;
virtual BOOL issteady () = 0; // Will false for return *any* change of activity.
virtual INT activity () = 0;
virtual BOOL isactive () = 0;
virtual BOOL isinactive () = 0;
virtual BOOL isposedge () = 0;
virtual BOOL isnegedge () = 0;
virtual BOOL isedge () = 0; // Will return true only for a full edge transition.
virtual EVENT *setstate (ABSTIME time, RELTIME tlh, RELTIME thl, RELTIME tgq, ST
ATE state) = 0;
virtual EVENT *setstate (ABSTIME time, RELTIME tgq, STATE state) = 0;
virtual VOID setstate (STATE state) = 0;
virtual VOID sethandler (IDSIMMODEL *model, PINHANDLERFN phf) = 0;
virtual DSIMNODE getnode() = 0;
virtual STATE getstate() = 0;
};
// Alternate drive interface interface - APIVER 1.10
class IDSIMPIN2 : public IDSIMPIN1
{ public:
virtual VOID settiming (RELTIME tlh, RELTIME thl, RELTIME tgq) = 0;
virtual VOID setstates (STATE tstate, STATE fstate, STATE zstate) = 0;
virtual EVENT *drivebool (ABSTIME time, BOOL flag) = 0;
virtual EVENT *drivestate (ABSTIME time, STATE state) = 0;
virtual EVENT *drivetristate (ABSTIME time) = 0;
};
// Interface to bus pin object - new in APIVER 1.10
class IBUSPIN
{ public:
virtual VOID settiming (RELTIME tlh, RELTIME thl, RELTIME tz) = 0;
virtual VOID setstates (STATE tstate, STATE fstate, STATE zstate) = 0;
virtual VOID sethandler (IDSIMMODEL *model, PINHANDLERFN phf) = 0;
virtual VOID drivebusvalue (ABSTIME time, DWORD value) = 0;
virtual VOID drivetristate (ABSTIME time) = 0;
virtual VOID drivebitstate (ABSTIME time, UINT bit, STATE state) = 0;
virtual DWORD getbusvalue() = 0;
virtual DWORD getbusdrive() = 0;
virtual STATE getbitstate(UINT bit) = 0;
};
// Interface to a digital model class.
class IDSIMMODEL
{ public:
virtual INT isdigital (CHAR *pinname) = 0;
virtual VOID setup (IINSTANCE *instance, IDSIMCKT *dsim) = 0;
virtual VOID runctrl (RUNMODES mode) = 0;
virtual VOID actuate (REALTIME time, ACTIVESTATE newstate) = 0;
virtual BOOL indicate (REALTIME time, ACTIVEDATA *newstate) = 0;
virtual VOID simulate (ABSTIME time, DSIMMODES mode) = 0;
virtual VOID callback (ABSTIME time, EVENTID eventid) = 0;
};
/************************************************** *******************
***** Mixed Model Interface ****
********************************/
// Interface to a mixed mode model class:
// This is actually just a combination of an ISPICEMODEL and an IDSIMMODEL.
class IMIXEDMODEL : public ISPICEMODEL, public IDSIMMODEL
{ public:
// Pin typing and connection functions:
virtual INT isanalog (CHAR *pinname) = 0;
virtual INT isdigital (CHAR *pinname) = 0;
// Common Functions:
virtual VOID runctrl (RUNMODES mode) = 0;
virtual VOID actuate (REALTIME time, ACTIVESTATE newstate) = 0;
virtual BOOL indicate (REALTIME time, ACTIVEDATA *newstate) = 0;
// Functions
virtual VOID
virtual VOID
rhs) = 0;
virtual VOID
virtual VOID
virtual VOID
called by SPICE:
setup (IINSTANCE *, ISPICECKT *spice) = 0;
dcload (REALTIME time, SPICEMODES mode, DOUBLE *oldrhs, DOUBLE *new
// Functions
virtual VOID
virtual VOID
virtual VOID
};
called by DSIM:
setup (IINSTANCE *, IDSIMCKT *dsim) = 0;
simulate (ABSTIME time, DSIMMODES mode) = 0;
callback (ABSTIME time, EVENTID eventid) = 0;
/************************************************** *******************
***** Active Event Messaging ****
*********************************/
// Struct for active component animation event:
enum ACTIVEDATATYPES
{ ADT_VOID=-1,
ADT_REAL,
ADT_BOOLEAN,
ADT_INTEGER,
ADT_STATE,
ADT_PINVOLTAGE,
ADT_PINSTATE,
ADT_WIREINFO,
ADT_SPICEDATA,
ADT_DSIMDATA,
ADT_USER=100
};
struct SPICEDATA
{ DWORD numtimepoints;
DWORD numpins;
REALTIME *timepoints;
DOUBLE *nodedata;
};
struct DSIMDATA
{ DWORD numtimepoints;
DWORD numpins;
ABSTIME *timepoints;
STATE *nodedata;
};
struct ACTIVEDATA
{ ACTIVEDATATYPES type;
union
{ INT intval;
DOUBLE realval;
STATE stateval;
DOUBLE wireinfo[2]; // Voltage and current
SPICEDATA spicedata;
DSIMDATA dsimdata;
VOID *userinfo; // Pointer to user data
};
};
struct ACTIVEEVENT
{ DWORD instance; // Design Global Instance value for target indicator
DWORD callback; // Callback Pointer to the active component object
DWORD element; // Sub-element within parent.
ACTIVEDATA data; // Data structure passed to models:
};
/************************************************** *******************
***** Popup Window Support ****
******************************/
// Data types and formats used by various popup window types
enum DATATYPES { DT_VOID=-1, DT_STRING, DT_TEXT, DT_BYTE, DT_WORD, DT_DWORD, DT_
QWORD, DT_IEEE_FLOAT, DT_IEEE_DOUBLE, DT_HTEC_FLOAT, DT_MCHP_FLOAT, DT_BIGENDIAN
=0x8000 };
enum DISPFORMATS { DF_VOID=-1, DF_BINARY, DF_OCTAL, DF_HEXADECIMAL, DF_SIGNED, D
F_UNSIGNED, DF_FLOAT, DF_TEXT };
// Backward compatibility
#define DT_LSF_WORD (DT_WORD)
#define DT_MSF_WORD (DT_WORD|DT_BIGENDIAN)
#define DT_LSF_DWORD (DT_DWORD)
#define DT_MSF_DWORD (DT_DWORD|DT_BIGENDIAN)
#define DT_LSF_QWORD (DT_QWORD)
#define DT_MSF_QWORD (DT_QWORD|DT_BIGENDIAN)
// Limits that can be used for arrays, menus IDs etc.
#define MAXDATATYPES 10
#define MAXDISPFORMATS 10
// ID's for system-global popups:
#define PID_LOGWINDOW 0
#define PID_WATCHWINDOW 1
// Interface through which windows messages can be passed to a USERPOPUP's owner
:
class IMSGHLR
{ public:
};
/************************************************** *******************
**** Definitions for VSM Debug Support ****
******************************************/
// See VDM.HPP
struct VDM_COMMAND;
// Variable Descriptor
struct VARITEM
{ CHAR name[WATCHITEM_NAME_SIZE];
DWORD loader, seg;
ADDRESS address;
DATATYPES type;
DISPFORMATS format;
DWORD size;
ADDRESS scope_begin;
ADDRESS scope_end;
};
// Variable Data structure
struct VARDATA
{ CHAR addr[WATCHITEM_ADDR_SIZE];
DATATYPES type;
BYTE *memory;
DWORD memsize;
DWORD offset; // from start of memory block.
};
// CPU Interface - CPU models derive off this to implement debug support.
class ICPU
{ public:
virtual LRESULT vdmhlr (VDM_COMMAND *cmd, BYTE *data) = 0;
virtual VOID loaddata (INT format, INT seg, ADDRESS address, BYTE *data, INT num
bytes) = 0;
virtual VOID disassemble (ADDRESS address, INT numbytes) = 0;
virtual BOOL getvardata (VARITEM *vip, VARDATA *vdp) = 0;
};
// Source debugging window:
class ISOURCEPOPUP
{ public:
virtual BOOL addsdifile (CHAR *file) = 0;
virtual BOOL setpcaddr (ADDRESS addr) = 0;
virtual BOOL isbreakpoint (ADDRESS addr) = 0;
virtual BOOL iscurrentline (ADDRESS addr) = 0;
virtual BOOL findfirstbpt (ADDRESS *addr) = 0;
virtual BOOL findnextbpt (ADDRESS *addr) = 0;
virtual
virtual
virtual
virtual
BOOL
VOID
VOID
VOID
virtual BOOL getsteptoaddr (ADDRESS *addr) = 0; // Added in release 5.20 SP1 (AP
IVER 1.03)
virtual VOID setinsertpos (INT fileid, INT linenum, BOOL newblock) = 0;
virtual VOID insertline (ADDRESS addr, CHAR *opcodes, CHAR *srctext) = 0; // Ins
ert a new line at the current position. (APIVER 1.05)
virtual BOOL findfirstsrcline (ADDRESS *addr) = 0;
virtual BOOL findnextsrcline (ADDRESS *addr) = 0;
virtual CHAR *findlabel (ADDRESS addr) = 0; // Return label for specified addres
s (APIVER 1.05)
};
// Variable Window - new in APIVER 1.05
class IVARPOPUP
{ public:
virtual VOID setcpu (ICPU *cpu) = 0;
virtual VOID additem (VARITEM *vip) = 0;
};
// Loader formats
#define FORMAT_BIN 0
#define FORMAT_HEX 1
#define FORMAT_S19 2
#define FORMAT_OMF51 3
#define FORMAT_UBROF 4
#define FORMAT_COD 5
#define FORMAT_BASIC 6
#define FORMAT_COFF 7
// Extern loader functions - implemented in LOADER.DLL
extern "C"
{ BOOL load_auto (CHAR *file, IINSTANCE *, ISOURCEPOPUP *, IVARPOPUP *, ICPU *);
BOOL load_bin (CHAR *file, IINSTANCE *, ISOURCEPOPUP *, IVARPOPUP *, ICPU *);
BOOL load_hex (CHAR *file, IINSTANCE *, ISOURCEPOPUP *, IVARPOPUP *, ICPU *);
BOOL load_s19 (CHAR *file, IINSTANCE *, ISOURCEPOPUP *, IVARPOPUP *, ICPU *);
BOOL load_omf51 (CHAR *file, IINSTANCE *, ISOURCEPOPUP *, IVARPOPUP *, ICPU *);
BOOL load_ubrof (CHAR *file, IINSTANCE *, ISOURCEPOPUP *, IVARPOPUP *, ICPU *);
BOOL load_cod (CHAR *file, IINSTANCE *, ISOURCEPOPUP *, IVARPOPUP *, ICPU *);
BOOL load_basic (CHAR *file, IINSTANCE *, ISOURCEPOPUP *, IVARPOPUP *, ICPU *);
BOOL load_coff (CHAR *file, IINSTANCE *, ISOURCEPOPUP *, IVARPOPUP *, ICPU *);
};
// Extern VSM Tools functions - implemented in VSMTOOLS.LIB
extern "C"
{ BOOL licence_model (ILICENCESERVER *ils, BOOL proonly=FALSE);
};
/************************************************** *******************
***** COM Instance Creation/Destruction ****
********************************************/
extern "C"
{ typedef IACTIVEMODEL *CREATEACTIVEMODELFN (CHAR *device, ILICENCESERVER *ils);
typedef VOID DELETEACTIVEMODELFN (IACTIVEMODEL *model);
typedef ISPICEMODEL *CREATESPICEMODELFN (CHAR *device, ILICENCESERVER *ils);
typedef VOID DELETESPICEMODELFN (ISPICEMODEL *);
typedef IDSIMMODEL *CREATEDSIMMODELFN (CHAR *device, ILICENCESERVER *ils);
typedef VOID DELETEDSIMMODELFN (IDSIMMODEL *);
typedef IMIXEDMODEL *CREATEMIXEDMODELFN (CHAR *device, ILICENCESERVER *ils);