Hi Mark,
Actually, the issues that need to be addressed first, are in Asyn.
Where the header files of a module (such as Asyn, in this case) import from another module (such as Com, in this case), but also in turn export to other modules (such as Motor, in this case), it is pretty essential to manipulate the epicsExportSharedSymbol define so that the importing headers each import, and the exporting headers each export.
See my attached header files from the Asyn module, which I believe are doing so correctly.
You'll see that epicsExportSharedSymbol is turned off before #including headers from the EPICS base.
Then the value of the define is cached, and restored, before being applied the definitions of (this) header.
This is quite well expressed in the comments of shareLib.h.
There are also some build issues in the Motor project that need to be looked at.
Cheers,
Peter.
-----Original Message-----
From: Mark Rivers [mailto:[email protected]]
Sent: 27 May 2015 12:05
To: Heesterman, Peter J; EPICS Tech Talk
Subject: RE: Motor R6-9 build issues on Windows
Hi Peter,
I fixed the problem with phytronAxisMotor back in March and committed to SVN.
I fixed many problems with NewportSrc on May 6 to get it to build on Cygwin, which is also much more sensitive to the correct name decorations than the Visual Studio release compiler. I committed those fixes to SVN as well. I have not tried building the win32-x86-debug arch, but my fixes for Cygwin may well have fixed those problems.
Can you try checking out the SVN trunk from /https://subversion.xray.aps.anl.gov/synApps/motor/trunk/ and see if there are still problems?
Mark
________________________________
From: [email protected] [[email protected]] on behalf of Heesterman, Peter J [[email protected]]
Sent: Wednesday, May 27, 2015 5:52 AM
To: EPICS Tech Talk
Subject: Motor R6-9 build issues on Windows
Hi,
I would like to highlight some build issues, on Windows, with the R6-9 release of the Motor project.
I am building with the following library versions:
a. Base 3.15.1
b. Seq 2.1.15
c. Ipac 2-10
d. Asyn 4-26
Trivial issue: phytronAxisMotor.cpp #includes unistd.h – which is not a header file under Windows.
Fix: The file isn’t required, as far as I can see, and can be removed.
Non-trivial issue: A release-x86 build completes normally, but a debug-x86 build fails with numerous DLL linker warnings and errors (see attached).
I’m not sure I understand why a debug build is so much more sensitive to these problems, than is a release build.
I would be able to address many of the build issues.
Thanks,
Peter.
/* asynDriver.h */
/***********************************************************************
* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
* National Laboratory, and the Regents of the University of
* California, as Operator of Los Alamos National Laboratory, and
* Berliner Elektronenspeicherring-Gesellschaft m.b.H. (BESSY).
* asynDriver is distributed subject to a Software License Agreement
* found in file LICENSE that is included with this distribution.
***********************************************************************/
/* Generic Asynchronous Driver support
* Author: Marty Kraimer
*/
#ifndef ASYNDRIVER_H
#define ASYNDRIVER_H
#ifdef epicsExportSharedSymbols
#define asynDriver_epicsExportSharedSymbols
#undef epicsExportSharedSymbols
#endif
#include <epicsStdio.h>
#include <epicsTime.h>
#include <ellLib.h>
#ifdef asynDriver_epicsExportSharedSymbols
#undef asynDriver_epicsExportSharedSymbols
#define epicsExportSharedSymbols
#endif
#include <shareLib.h>
/* Version number names similar to those provide by base
* These macros are always numeric */
#define ASYN_VERSION 4
#define ASYN_REVISION 26
#define ASYN_MODIFICATION 0
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
typedef enum {
asynSuccess,asynTimeout,asynOverflow,asynError,asynDisconnected,asynDisabled
}asynStatus;
typedef enum {
asynExceptionConnect,asynExceptionEnable,asynExceptionAutoConnect,
asynExceptionTraceMask,asynExceptionTraceIOMask,asynExceptionTraceInfoMask,
asynExceptionTraceFile,asynExceptionTraceIOTruncateSize
} asynException;
typedef enum {
asynQueuePriorityLow,asynQueuePriorityMedium,asynQueuePriorityHigh,
asynQueuePriorityConnect
}asynQueuePriority;
typedef struct asynUser {
char *errorMessage;
int errorMessageSize;
/* timeout must be set by the user */
double timeout; /*Timeout for I/O operations*/
void *userPvt;
void *userData;
/*The following is for user to/from driver communication*/
void *drvUser;
/*The following is normally set by driver*/
int reason;
epicsTimeStamp timestamp;
/* The following are for additional information from method calls */
int auxStatus; /*For auxillary status*/
}asynUser;
typedef struct asynInterface{
const char *interfaceType; /*For example asynCommonType*/
void *pinterface; /*For example pasynCommon */
void *drvPvt;
}asynInterface;
/*registerPort attributes*/
#define ASYN_MULTIDEVICE 0x0001
#define ASYN_CANBLOCK 0x0002
/*standard values for asynUser.reason*/
#define ASYN_REASON_SIGNAL -1
#define ASYN_REASON_RESERVED_LOW 0x70000000
#define ASYN_REASON_RESERVED_HIGH 0x7FFFFFFF
#define ASYN_REASON_QUEUE_EVEN_IF_NOT_CONNECTED ASYN_REASON_RESERVED_LOW
typedef void (*userCallback)(asynUser *pasynUser);
typedef void (*exceptionCallback)(asynUser *pasynUser,asynException exception);
typedef void (*timeStampCallback)(void *userPvt, epicsTimeStamp *pTimeStamp);
typedef struct interruptNode{
ELLNODE node;
void *drvPvt;
}interruptNode;
typedef struct asynManager {
void (*report)(FILE *fp,int details,const char*portName);
asynUser *(*createAsynUser)(userCallback process,userCallback timeout);
asynUser *(*duplicateAsynUser)(asynUser *pasynUser,
userCallback queue,userCallback timeout);
asynStatus (*freeAsynUser)(asynUser *pasynUser);
void *(*memMalloc)(size_t size);
void (*memFree)(void *pmem,size_t size);
asynStatus (*isMultiDevice)(asynUser *pasynUser,
const char *portName,int *yesNo);
/* addr = (-1,>=0) => connect to (port,device) */
asynStatus (*connectDevice)(asynUser *pasynUser,
const char *portName,int addr);
asynStatus (*disconnect)(asynUser *pasynUser);
asynStatus (*exceptionCallbackAdd)(asynUser *pasynUser,
exceptionCallback callback);
asynStatus (*exceptionCallbackRemove)(asynUser *pasynUser);
asynInterface *(*findInterface)(asynUser *pasynUser,
const char *interfaceType,int interposeInterfaceOK);
asynStatus (*queueRequest)(asynUser *pasynUser,
asynQueuePriority priority,double timeout);
asynStatus (*cancelRequest)(asynUser *pasynUser,int *wasQueued);
asynStatus (*blockProcessCallback)(asynUser *pasynUser, int allDevices);
asynStatus (*unblockProcessCallback)(asynUser *pasynUser, int allDevices);
asynStatus (*lockPort)(asynUser *pasynUser);
asynStatus (*unlockPort)(asynUser *pasynUser);
asynStatus (*queueLockPort)(asynUser *pasynUser);
asynStatus (*queueUnlockPort)(asynUser *pasynUser);
asynStatus (*canBlock)(asynUser *pasynUser,int *yesNo);
asynStatus (*getAddr)(asynUser *pasynUser,int *addr);
asynStatus (*getPortName)(asynUser *pasynUser,const char **pportName);
/* drivers call the following*/
asynStatus (*registerPort)(const char *portName,
int attributes,int autoConnect,
unsigned int priority,unsigned int stackSize);
asynStatus (*registerInterface)(const char *portName,
asynInterface *pasynInterface);
asynStatus (*exceptionConnect)(asynUser *pasynUser);
asynStatus (*exceptionDisconnect)(asynUser *pasynUser);
/*any code can call the following*/
asynStatus (*interposeInterface)(const char *portName, int addr,
asynInterface *pasynInterface,
asynInterface **ppPrev);
asynStatus (*enable)(asynUser *pasynUser,int yesNo);
asynStatus (*autoConnect)(asynUser *pasynUser,int yesNo);
asynStatus (*isConnected)(asynUser *pasynUser,int *yesNo);
asynStatus (*isEnabled)(asynUser *pasynUser,int *yesNo);
asynStatus (*isAutoConnect)(asynUser *pasynUser,int *yesNo);
asynStatus (*setAutoConnectTimeout)(double timeout);
asynStatus (*waitConnect)(asynUser *pasynUser, double timeout);
/*The following are methods for interrupts*/
asynStatus (*registerInterruptSource)(const char *portName,
asynInterface *pasynInterface, void **pasynPvt);
asynStatus (*getInterruptPvt)(asynUser *pasynUser,
const char *interfaceType, void **pasynPvt);
interruptNode *(*createInterruptNode)(void *pasynPvt);
asynStatus (*freeInterruptNode)(asynUser *pasynUser,interruptNode *pnode);
asynStatus (*addInterruptUser)(asynUser *pasynUser,
interruptNode*pinterruptNode);
asynStatus (*removeInterruptUser)(asynUser *pasynUser,
interruptNode*pinterruptNode);
asynStatus (*interruptStart)(void *pasynPvt,ELLLIST **plist);
asynStatus (*interruptEnd)(void *pasynPvt);
/* Time stamp functions */
asynStatus (*registerTimeStampSource)(asynUser *pasynUser, void *userPvt, timeStampCallback callback);
asynStatus (*unregisterTimeStampSource)(asynUser *pasynUser);
asynStatus (*updateTimeStamp)(asynUser *pasynUser);
asynStatus (*getTimeStamp)(asynUser *pasynUser, epicsTimeStamp *pTimeStamp);
asynStatus (*setTimeStamp)(asynUser *pasynUser, const epicsTimeStamp *pTimeStamp);
const char *(*strStatus)(asynStatus status);
}asynManager;
epicsShareExtern asynManager *pasynManager;
/* Interface supported by ALL asyn drivers*/
#define asynCommonType "asynCommon"
typedef struct asynCommon {
/*report does not have to be called from queueRequest*/
void (*report)(void *drvPvt,FILE *fp,int details);
asynStatus (*connect)(void *drvPvt,asynUser *pasynUser);
asynStatus (*disconnect)(void *drvPvt,asynUser *pasynUser);
}asynCommon;
/* asynLockPortNotify is for address change drivers */
#define asynLockPortNotifyType "asynLockPortNotify"
typedef struct asynLockPortNotify {
asynStatus (*lock)(void *drvPvt,asynUser *pasynUser);
asynStatus (*unlock)(void *drvPvt,asynUser *pasynUser);
}asynLockPortNotify;
/*asynTrace is implemented by asynManager*/
/*All asynTrace methods can be called from any thread*/
/* traceMask definitions*/
#define ASYN_TRACE_ERROR 0x0001
#define ASYN_TRACEIO_DEVICE 0x0002
#define ASYN_TRACEIO_FILTER 0x0004
#define ASYN_TRACEIO_DRIVER 0x0008
#define ASYN_TRACE_FLOW 0x0010
#define ASYN_TRACE_WARNING 0x0020
/* traceIO mask definitions*/
#define ASYN_TRACEIO_NODATA 0x0000
#define ASYN_TRACEIO_ASCII 0x0001
#define ASYN_TRACEIO_ESCAPE 0x0002
#define ASYN_TRACEIO_HEX 0x0004
/* traceInfo mask definitions*/
#define ASYN_TRACEINFO_TIME 0x0001
#define ASYN_TRACEINFO_PORT 0x0002
#define ASYN_TRACEINFO_SOURCE 0x0004
#define ASYN_TRACEINFO_THREAD 0x0008
/* asynPrint and asynPrintIO are macros that act like
int asynPrint(asynUser *pasynUser,int reason, const char *format, ... );
int asynPrintIO(asynUser *pasynUser,int reason,
const char *buffer, size_t len, const char *format, ... );
*/
typedef struct asynTrace {
/* lock/unlock are only necessary if caller performs I/O other than */
/* by calling asynTrace methods */
asynStatus (*lock)(asynUser *pasynUser);
asynStatus (*unlock)(asynUser *pasynUser);
asynStatus (*setTraceMask)(asynUser *pasynUser,int mask);
int (*getTraceMask)(asynUser *pasynUser);
asynStatus (*setTraceIOMask)(asynUser *pasynUser,int mask);
int (*getTraceIOMask)(asynUser *pasynUser);
asynStatus (*setTraceInfoMask)(asynUser *pasynUser,int mask);
int (*getTraceInfoMask)(asynUser *pasynUser);
asynStatus (*setTraceFile)(asynUser *pasynUser,FILE *fp);
FILE *(*getTraceFile)(asynUser *pasynUser);
asynStatus (*setTraceIOTruncateSize)(asynUser *pasynUser,size_t size);
size_t (*getTraceIOTruncateSize)(asynUser *pasynUser);
#if defined(__GNUC__) && (__GNUC__ < 3)
/* GCC 2.95 does not allow EPICS_PRINTF_STYLE on function pointers */
int (*print)(asynUser *pasynUser,int reason, const char *pformat, ...);
int (*printSource)(asynUser *pasynUser,int reason, const char *fileName, int line, const char *pformat, ...);
int (*vprint)(asynUser *pasynUser,int reason, const char *pformat, va_list pvar);
int (*vprintSource)(asynUser *pasynUser,int reason, const char *file, int line, const char *pformat, va_list pvar);
int (*printIO)(asynUser *pasynUser,int reason,
const char *buffer, size_t len,const char *pformat, ...);
int (*printIOSource)(asynUser *pasynUser,int reason,
const char *buffer, size_t len,const char *file, int line, const char *pformat, ...);
int (*vprintIO)(asynUser *pasynUser,int reason,
const char *buffer, size_t len,const char *pformat, va_list pvar);
int (*vprintIOSource)(asynUser *pasynUser,int reason,
const char *buffer, size_t len,const char *file, int line, const char *pformat, va_list pvar);
#else
int (*print)(asynUser *pasynUser,int reason, const char *pformat, ...) EPICS_PRINTF_STYLE(3,4);
int (*printSource)(asynUser *pasynUser,int reason, const char *fileName, int line, const char *pformat, ...) EPICS_PRINTF_STYLE(5,6);
int (*vprint)(asynUser *pasynUser,int reason, const char *pformat, va_list pvar) EPICS_PRINTF_STYLE(3,0);
int (*vprintSource)(asynUser *pasynUser,int reason, const char *file, int line, const char *pformat, va_list pvar) EPICS_PRINTF_STYLE(5,0);
int (*printIO)(asynUser *pasynUser,int reason,
const char *buffer, size_t len,const char *pformat, ...) EPICS_PRINTF_STYLE(5,6);
int (*printIOSource)(asynUser *pasynUser,int reason,
const char *buffer, size_t len,const char *file, int line, const char *pformat, ...) EPICS_PRINTF_STYLE(7,8);
int (*vprintIO)(asynUser *pasynUser,int reason,
const char *buffer, size_t len,const char *pformat, va_list pvar) EPICS_PRINTF_STYLE(5,0);
int (*vprintIOSource)(asynUser *pasynUser,int reason,
const char *buffer, size_t len,const char *file, int line, const char *pformat, va_list pvar) EPICS_PRINTF_STYLE(7,0);
#endif
}asynTrace;
epicsShareExtern asynTrace *pasynTrace;
#if (defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L) || defined(_WIN32)
#define asynPrint(pasynUser,reason, ...) \
((pasynTrace->getTraceMask((pasynUser))&(reason)) \
? pasynTrace->printSource((pasynUser),(reason),__FILE__,__LINE__,__VA_ARGS__) \
: 0)
#elif defined(__GNUC__)
#define asynPrint(pasynUser,reason,format...) \
((pasynTrace->getTraceMask((pasynUser))&(reason)) \
? pasynTrace->printSource(pasynUser,reason,__FILE__,__LINE__,format) \
: 0)
#else
#define asynPrint pasynTrace->print
#endif
#if (defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L) || defined(_WIN32)
#define asynPrintIO(pasynUser,reason,buffer,len, ...) \
((pasynTrace->getTraceMask((pasynUser))&(reason)) \
? pasynTrace->printIOSource((pasynUser),(reason),(buffer),(len),__FILE__,__LINE__,__VA_ARGS__) \
: 0)
#elif defined(__GNUC__)
#define asynPrintIO(pasynUser,reason,buffer,len,format...) \
((pasynTrace->getTraceMask((pasynUser))&(reason)) \
? pasynTrace->printIOSource((pasynUser),(reason),(buffer),(len),__FILE__,__LINE__,format) \
: 0)
#else
#define asynPrintIO pasynTrace->printIO
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* ASYNDRIVER_H */
#ifndef asynparamVal_H
#define asynparamVal_H
#ifdef epicsExportSharedSymbols
#define paramVal_epicsExportSharedSymbols
#undef epicsExportSharedSymbols
#endif
#include "stdio.h"
#include "epicsTypes.h"
#ifdef paramVal_epicsExportSharedSymbols
#undef paramVal_epicsExportSharedSymbols
#define epicsExportSharedSymbols
#endif
#include "asynParamType.h"
#include "asynDriver.h"
#ifdef __cplusplus
/** Structure for storing parameter value in parameter library */
class paramVal {
public:
paramVal(const char *name);
paramVal(const char *name, asynParamType type);
bool isDefined();
void setDefined(bool defined);
bool hasValueChanged();
void setValueChanged();
void resetValueChanged();
void setStatus(asynStatus status);
asynStatus getStatus();
char* getName();
bool nameEquals(const char* name);
void setInteger(epicsInt32 value);
epicsInt32 getInteger();
void setUInt32(epicsUInt32 value, epicsUInt32 valueMask, epicsUInt32 interruptMask);
epicsUInt32 getUInt32(epicsUInt32 valueMask);
void setDouble(epicsFloat64 value);
epicsFloat64 getDouble();
void setString(const char *value);
char *getString();
void report(int id, FILE *fp, int details);
const char* getTypeName();
asynParamType type; /**< Parameter data type */
static const char* typeNames[];
epicsUInt32 uInt32RisingMask;
epicsUInt32 uInt32FallingMask;
epicsUInt32 uInt32CallbackMask;
protected:
asynStatus status_;
bool valueDefined;
bool valueChanged;
char *name; /**< Parameter name */
/** Union for parameter value */
union
{
epicsInt32 ival;
epicsUInt32 uival;
epicsFloat64 dval;
char *sval;
epicsInt8 *pi8;
epicsInt16 *pi16;
epicsInt32 *pi32;
epicsFloat32 *pf32;
epicsFloat64 *pf64;
void *pgp;
} data;
};
#endif /* cplusplus */
#endif
#ifndef asynPortDriver_H
#define asynPortDriver_H
#ifdef epicsExportSharedSymbols
#define asynPortDriver_epicsExportSharedSymbols
#undef epicsExportSharedSymbols
#endif
#include <epicsTypes.h>
#include <epicsMutex.h>
#ifdef asynPortDriver_epicsExportSharedSymbols
#undef asynPortDriver_epicsExportSharedSymbols
#define epicsExportSharedSymbols
#endif
#include <shareLib.h>
#include <asynStandardInterfaces.h>
#include "paramVal.h"
class paramList;
epicsShareFunc void* findAsynPortDriver(const char *portName);
typedef void (*userTimeStampFunction)(void *userPvt, epicsTimeStamp *pTimeStamp);
#ifdef __cplusplus
/** Masks for each of the asyn standard interfaces */
#define asynCommonMask 0x00000001
#define asynDrvUserMask 0x00000002
#define asynOptionMask 0x00000004
#define asynInt32Mask 0x00000008
#define asynUInt32DigitalMask 0x00000010
#define asynFloat64Mask 0x00000020
#define asynOctetMask 0x00000040
#define asynInt8ArrayMask 0x00000080
#define asynInt16ArrayMask 0x00000100
#define asynInt32ArrayMask 0x00000200
#define asynFloat32ArrayMask 0x00000400
#define asynFloat64ArrayMask 0x00000800
#define asynGenericPointerMask 0x00001000
#define asynEnumMask 0x00002000
/** Base class for asyn port drivers; handles most of the bookkeeping for writing an asyn port driver
* with standard asyn interfaces and a parameter library. */
class epicsShareClass asynPortDriver {
public:
asynPortDriver(const char *portName, int maxAddr, int paramTableSize, int interfaceMask, int interruptMask,
int asynFlags, int autoConnect, int priority, int stackSize);
virtual ~asynPortDriver();
virtual asynStatus lock();
virtual asynStatus unlock();
virtual asynStatus getAddress(asynUser *pasynUser, int *address);
virtual asynStatus readInt32(asynUser *pasynUser, epicsInt32 *value);
virtual asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value);
virtual asynStatus readUInt32Digital(asynUser *pasynUser, epicsUInt32 *value, epicsUInt32 mask);
virtual asynStatus writeUInt32Digital(asynUser *pasynUser, epicsUInt32 value, epicsUInt32 mask);
virtual asynStatus setInterruptUInt32Digital(asynUser *pasynUser, epicsUInt32 mask, interruptReason reason);
virtual asynStatus clearInterruptUInt32Digital(asynUser *pasynUser, epicsUInt32 mask);
virtual asynStatus getInterruptUInt32Digital(asynUser *pasynUser, epicsUInt32 *mask, interruptReason reason);
virtual asynStatus getBounds(asynUser *pasynUser, epicsInt32 *low, epicsInt32 *high);
virtual asynStatus readFloat64(asynUser *pasynUser, epicsFloat64 *value);
virtual asynStatus writeFloat64(asynUser *pasynUser, epicsFloat64 value);
virtual asynStatus readOctet(asynUser *pasynUser, char *value, size_t maxChars,
size_t *nActual, int *eomReason);
virtual asynStatus writeOctet(asynUser *pasynUser, const char *value, size_t maxChars,
size_t *nActual);
virtual asynStatus flushOctet(asynUser *pasynUser);
virtual asynStatus setInputEosOctet(asynUser *pasynUser, const char *eos, int eosLen);
virtual asynStatus getInputEosOctet(asynUser *pasynUser, char *eos, int eosSize, int *eosLen);
virtual asynStatus setOutputEosOctet(asynUser *pasynUser, const char *eos, int eosLen);
virtual asynStatus getOutputEosOctet(asynUser *pasynUser, char *eos, int eosSize, int *eosLen);
virtual asynStatus readInt8Array(asynUser *pasynUser, epicsInt8 *value,
size_t nElements, size_t *nIn);
virtual asynStatus writeInt8Array(asynUser *pasynUser, epicsInt8 *value,
size_t nElements);
virtual asynStatus doCallbacksInt8Array(epicsInt8 *value,
size_t nElements, int reason, int addr);
virtual asynStatus readInt16Array(asynUser *pasynUser, epicsInt16 *value,
size_t nElements, size_t *nIn);
virtual asynStatus writeInt16Array(asynUser *pasynUser, epicsInt16 *value,
size_t nElements);
virtual asynStatus doCallbacksInt16Array(epicsInt16 *value,
size_t nElements, int reason, int addr);
virtual asynStatus readInt32Array(asynUser *pasynUser, epicsInt32 *value,
size_t nElements, size_t *nIn);
virtual asynStatus writeInt32Array(asynUser *pasynUser, epicsInt32 *value,
size_t nElements);
virtual asynStatus doCallbacksInt32Array(epicsInt32 *value,
size_t nElements, int reason, int addr);
virtual asynStatus readFloat32Array(asynUser *pasynUser, epicsFloat32 *value,
size_t nElements, size_t *nIn);
virtual asynStatus writeFloat32Array(asynUser *pasynUser, epicsFloat32 *value,
size_t nElements);
virtual asynStatus doCallbacksFloat32Array(epicsFloat32 *value,
size_t nElements, int reason, int addr);
virtual asynStatus readFloat64Array(asynUser *pasynUser, epicsFloat64 *value,
size_t nElements, size_t *nIn);
virtual asynStatus writeFloat64Array(asynUser *pasynUser, epicsFloat64 *value,
size_t nElements);
virtual asynStatus doCallbacksFloat64Array(epicsFloat64 *value,
size_t nElements, int reason, int addr);
virtual asynStatus readGenericPointer(asynUser *pasynUser, void *pointer);
virtual asynStatus writeGenericPointer(asynUser *pasynUser, void *pointer);
virtual asynStatus doCallbacksGenericPointer(void *pointer, int reason, int addr);
virtual asynStatus readOption(asynUser *pasynUser, const char *key, char *value, int maxChars);
virtual asynStatus writeOption(asynUser *pasynUser, const char *key, const char *value);
virtual asynStatus readEnum(asynUser *pasynUser, char *strings[], int values[], int severities[], size_t nElements, size_t *nIn);
virtual asynStatus writeEnum(asynUser *pasynUser, char *strings[], int values[], int severities[], size_t nElements);
virtual asynStatus doCallbacksEnum(char *strings[], int values[], int severities[], size_t nElements, int reason, int addr);
virtual asynStatus drvUserCreate(asynUser *pasynUser, const char *drvInfo,
const char **pptypeName, size_t *psize);
virtual asynStatus drvUserGetType(asynUser *pasynUser,
const char **pptypeName, size_t *psize);
virtual asynStatus drvUserDestroy(asynUser *pasynUser);
virtual void report(FILE *fp, int details);
virtual asynStatus connect(asynUser *pasynUser);
virtual asynStatus disconnect(asynUser *pasynUser);
virtual asynStatus createParam( const char *name, asynParamType type, int *index);
virtual asynStatus createParam(int list, const char *name, asynParamType type, int *index);
virtual asynStatus findParam( const char *name, int *index);
virtual asynStatus findParam(int list, const char *name, int *index);
virtual asynStatus getParamName( int index, const char **name);
virtual asynStatus getParamName(int list, int index, const char **name);
virtual asynStatus setParamStatus( int index, asynStatus status);
virtual asynStatus setParamStatus(int list, int index, asynStatus status);
virtual asynStatus getParamStatus( int index, asynStatus *status);
virtual asynStatus getParamStatus(int list, int index, asynStatus *status);
virtual void reportSetParamErrors(asynStatus status, int index, int list, const char *functionName);
virtual void reportGetParamErrors(asynStatus status, int index, int list, const char *functionName);
virtual asynStatus setIntegerParam( int index, int value);
virtual asynStatus setIntegerParam(int list, int index, int value);
virtual asynStatus setUIntDigitalParam( int index, epicsUInt32 value, epicsUInt32 valueMask);
virtual asynStatus setUIntDigitalParam(int list, int index, epicsUInt32 value, epicsUInt32 valueMask);
virtual asynStatus setUIntDigitalParam( int index, epicsUInt32 value, epicsUInt32 valueMask, epicsUInt32 interruptMask);
virtual asynStatus setUIntDigitalParam(int list, int index, epicsUInt32 value, epicsUInt32 valueMask, epicsUInt32 interruptMask);
virtual asynStatus setUInt32DigitalInterrupt( int index, epicsUInt32 mask, interruptReason reason);
virtual asynStatus setUInt32DigitalInterrupt(int list, int index, epicsUInt32 mask, interruptReason reason);
virtual asynStatus clearUInt32DigitalInterrupt( int index, epicsUInt32 mask);
virtual asynStatus clearUInt32DigitalInterrupt(int list, int index, epicsUInt32 mask);
virtual asynStatus getUInt32DigitalInterrupt( int index, epicsUInt32 *mask, interruptReason reason);
virtual asynStatus getUInt32DigitalInterrupt(int list, int index, epicsUInt32 *mask, interruptReason reason);
virtual asynStatus setDoubleParam( int index, double value);
virtual asynStatus setDoubleParam(int list, int index, double value);
virtual asynStatus setStringParam( int index, const char *value);
virtual asynStatus setStringParam(int list, int index, const char *value);
virtual asynStatus getIntegerParam( int index, int * value);
virtual asynStatus getIntegerParam(int list, int index, int * value);
virtual asynStatus getUIntDigitalParam( int index, epicsUInt32 *value, epicsUInt32 mask);
virtual asynStatus getUIntDigitalParam(int list, int index, epicsUInt32 *value, epicsUInt32 mask);
virtual asynStatus getDoubleParam( int index, double * value);
virtual asynStatus getDoubleParam(int list, int index, double * value);
virtual asynStatus getStringParam( int index, int maxChars, char *value);
virtual asynStatus getStringParam(int list, int index, int maxChars, char *value);
virtual asynStatus callParamCallbacks();
virtual asynStatus callParamCallbacks( int addr);
virtual asynStatus callParamCallbacks(int list, int addr);
virtual asynStatus updateTimeStamp();
virtual asynStatus updateTimeStamp(epicsTimeStamp *pTimeStamp);
virtual asynStatus getTimeStamp(epicsTimeStamp *pTimeStamp);
virtual asynStatus setTimeStamp(const epicsTimeStamp *pTimeStamp);
asynStandardInterfaces *getAsynStdInterfaces();
virtual void reportParams(FILE *fp, int details);
char *portName; /**< The name of this asyn port */
int maxAddr; /**< The maximum asyn address (addr) supported by this driver */
void callbackTask();
protected:
asynUser *pasynUserSelf; /**< asynUser connected to ourselves for asynTrace */
asynStandardInterfaces asynStdInterfaces; /**< The asyn interfaces this driver implements */
private:
paramList **params;
epicsMutexId mutexId;
char *inputEosOctet;
int inputEosLenOctet;
char *outputEosOctet;
int outputEosLenOctet;
template <typename epicsType, typename interruptType>
asynStatus doCallbacksArray(epicsType *value, size_t nElements,
int reason, int address, void *interruptPvt);
};
#endif /* cplusplus */
#endif
- Replies:
- RE: Motor R6-9 build issues on Windows Mark Rivers
- RE: Motor R6-9 build issues on Windows Mark Rivers
- References:
- Motor R6-9 build issues on Windows Heesterman, Peter J
- RE: Motor R6-9 build issues on Windows Mark Rivers
- Navigate by Date:
- Prev:
RE: Motor R6-9 build issues on Windows Mark Rivers
- Next:
RE: Motor R6-9 build issues on Windows Mark Rivers
- Index:
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
<2015>
2016
2017
2018
2019
2020
2021
2022
2023
2024
- Navigate by Thread:
- Prev:
RE: Motor R6-9 build issues on Windows Mark Rivers
- Next:
RE: Motor R6-9 build issues on Windows Mark Rivers
- Index:
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
<2015>
2016
2017
2018
2019
2020
2021
2022
2023
2024
|
·
Home
·
News
·
About
·
Base
·
Modules
·
Extensions
·
Distributions
·
Download
·