vsm.hpp

创建基于DLL的Proteus VSM仿真模型

/*********************************************************************
*****  Generic Simulator Interface ****
**************************************/

// Time type definitions:
typedef DOUBLE REALTIME;
typedef LONGLONG  ABSTIME;
typedef const ABSTIME &CREFABSTIME;
typedef LONGLONG RELTIME;
typedef const RELTIME &CREFRELTIME;

// Time Conversion Macros
#define DSIMTICK    1e-12

// Maximum bits in bus:
#define MAXBUSBITS     32

//#define dsimtime(t) ABSTIME((t)/DSIMTICK)
//#define realtime(t) REALTIME((t)*DSIMTICK)
inline ABSTIME  dsimtime(DOUBLE t) { return ABSTIME((t)/DSIMTICK); }
inline REALTIME realtime(ABSTIME t) { return REALTIME((t)*DSIMTICK); }


// Simulator Run Control Modes
enum RUNMODES
 { RM_BATCH=-1,
   RM_START,
   RM_STOP,
   RM_SUSPEND,
   RM_ANIMATE,
   RM_STEPTIME,
   RM_STEPOVER,
   RM_STEPINTO,
   RM_STEPOUT,
   RM_STEPTO,
   RM_META,
   RM_DUMP
 };

// Public Interface to a simulator component instance.
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, UINT 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 *newrhs) = 0;
      virtual VOID acload (SPICEFREQ omega, DOUBLE *rhs, DOUBLE *irhs) = 0;
      virtual VOID trunc  (REALTIME time,  REALTIME *newtimestep) = 0;
      virtual VOID accept (REALTIME time, DOUBLE *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 not 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, CALLBACKHANDLERFN 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, STATE 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;