vsm.h

频谱仪锂电池电量表,非常适合学习和使用单片机开发的人用

      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 called by SPICE:
      virtual VOID setup (IINSTANCE *, ISPICECKT *spice) = 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;

      // Functions called by DSIM:
      virtual VOID setup (IINSTANCE *, IDSIMCKT *dsim) = 0;
      virtual VOID simulate (ABSTIME time, DSIMMODES mode) = 0;
      virtual VOID 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, DF_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:
      virtual LRESULT msghlr (HWND, MESSAGE, WPARAM, LPARAM) = 0;
 };

// User defined popup window:
class IUSERPOPUP
 { public:
      virtual CHAR *getprop (CHAR *key) = 0;
      virtual VOID setprop (CHAR *key, CHAR *value) = 0;
      virtual VOID setmsghlr (IMSGHLR *handler) = 0;
      virtual LRESULT callwindowproc (MESSAGE msg, WPARAM warg, LPARAM larg) = 0;
 };

// Debug/logging window:
class IDEBUGPOPUP
 { public:
      virtual VOID print (CHAR *msg, ...) = 0;
      virtual VOID dump (const BYTE *ptr, UINT nbytes, UINT base=0) = 0;
 };

// Status display window:
class ISTATUSPOPUP
 { public:
      virtual VOID setarea (UINT columns, UINT rows, UINT border, BOOL copy) = 0;
      virtual VOID setcursorto (UINT pixelx, UINT pixely) = 0;
      virtual UINT getcharwidth (VOID) = 0;
      virtual UINT getcharheight (VOID) = 0;
      virtual VOID print (CHAR *message, ...) = 0;
      virtual VOID print (INT col, INT row, COLOUR textcolour, CHAR *msg, ...) = 0;
      virtual VOID setctabstops (const INT ts[], INT n) = 0;
      virtual VOID setptabstops (const INT ts[], INT n) = 0;
      virtual VOID clear (COLOUR bkcolour=NOCOLOUR) = 0;
      virtual BOOL setredraw (BOOL on_off, BOOL redraw_now) = 0;
      virtual VOID repaint (VOID) = 0;
 };

// Memory dump window:
class IMEMORYPOPUP
 { public:
      virtual VOID setmemory (ADDRESS baseaddr, BYTE *data, UINT nbytes) = 0;
      virtual VOID repaint (VOID) = 0;
 };


// Watch window interface
#define WATCHITEM_NAME_SIZE 128
#define WATCHITEM_ADDR_SIZE 32

class IWATCHPOPUP
 { public:
      // Offset is the byte offset within the memory block independent of any 'base' associated with the memory
      // window. For example, if offset is '4' we are refering to the fourth byte in the memory block; if the memory
      // block as an implied base of, say, 12, this would be address '16'.
      virtual VOID addnameditem (CHAR *name, IMEMORYPOPUP *, DWORD offset, DATATYPES type, DISPFORMATS format) = 0;

      // This interfaces are used by PROSPICE itself to poll for watchpoints
      virtual BOOL initwatchpoints () = 0;
      virtual BOOL testwatchpoints () = 0;

 };



/*********************************************************************
**** 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 numbytes) = 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 BOOL addsrcfile (CHAR *file, BOOL lowlevel) = 0;
      virtual VOID addcodeline (INT srclinenum, ADDRESS address) = 0;
      virtual VOID addcodelabel (CHAR *label, ADDRESS address) = 0;
      virtual VOID update () = 0;

      virtual BOOL getsteptoaddr (ADDRESS *addr) = 0;                            // Added in release 5.20 SP1 (APIVER 1.03)
      virtual VOID setinsertpos (INT fileid, INT linenum, BOOL newblock) = 0;
      virtual VOID insertline (ADDRESS addr, CHAR *opcodes, CHAR *srctext) = 0;  // Insert 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 address (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);
   typedef VOID DELETEMIXEDMODELFN (IMIXEDMODEL *);
 }

#pragma pack(pop)

#endif