1 #ifndef asynPortClient_H
2 #define asynPortClient_H
7 #include <epicsString.h>
9 #include <asynDriver.h>
10 #include <asynInt32.h>
11 #include <asynInt32SyncIO.h>
12 #include <asynUInt32Digital.h>
13 #include <asynUInt32DigitalSyncIO.h>
14 #include <asynFloat64.h>
15 #include <asynFloat64SyncIO.h>
16 #include <asynOctet.h>
17 #include <asynOctetSyncIO.h>
18 #include <asynInt8Array.h>
19 #include <asynInt8ArraySyncIO.h>
20 #include <asynInt16Array.h>
21 #include <asynInt16ArraySyncIO.h>
22 #include <asynInt32Array.h>
23 #include <asynInt32ArraySyncIO.h>
24 #include <asynFloat32Array.h>
25 #include <asynFloat32ArraySyncIO.h>
26 #include <asynFloat64Array.h>
27 #include <asynFloat64ArraySyncIO.h>
28 #include <asynGenericPointer.h>
29 #include <asynGenericPointerSyncIO.h>
31 #include <asynEnumSyncIO.h>
32 #include <asynOption.h>
33 #include <asynOptionSyncIO.h>
34 #include <asynCommonSyncIO.h>
35 #include <asynDrvUser.h>
37 #define DEFAULT_TIMEOUT 1.0
44 asynPortClient(
const char *portName,
int addr,
const char* asynInterfaceType,
const char *drvInfo,
double timeout);
47 { timeout_ = timeout; };
48 void report(FILE *fp,
int details);
73 :
asynPortClient(portName, addr, asynInt32Type, drvInfo, timeout) {
74 pInterface_ = (asynInt32 *)pasynInterface_->pinterface;
75 if (pasynInt32SyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
76 throw std::runtime_error(std::string(
"pasynInt32SyncIO->connect failed"));
80 if (pInterface_ && interruptPvt_)
81 pInterface_->cancelInterruptUser(pasynInterface_->drvPvt, pasynUser_, interruptPvt_);
82 pasynInt32SyncIO->disconnect(pasynUserSyncIO_);
86 virtual asynStatus
read(epicsInt32 *value) {
87 return pasynInt32SyncIO->read(pasynUserSyncIO_, value, timeout_);
91 virtual asynStatus
write(epicsInt32 value) {
92 return pasynInt32SyncIO->write(pasynUserSyncIO_, value, timeout_);
97 virtual asynStatus
getBounds(epicsInt32 *low, epicsInt32 *high) {
98 return pasynInt32SyncIO->getBounds(pasynUserSyncIO_, low, high);
103 if(interruptPvt_!=NULL)
return asynError;
104 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
105 pCallback,
this, &interruptPvt_);
108 asynInt32 *pInterface_;
122 :
asynPortClient(portName, addr, asynUInt32DigitalType, drvInfo, timeout) {
123 pInterface_ = (asynUInt32Digital *)pasynInterface_->pinterface;
124 if (pasynInt32SyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
125 throw std::runtime_error(std::string(
"pasynInt32SyncIO->connect failed"));
129 pasynUInt32DigitalSyncIO->disconnect(pasynUserSyncIO_);
134 virtual asynStatus
read(epicsUInt32 *value, epicsUInt32 mask) {
135 return pasynUInt32DigitalSyncIO->read(pasynUserSyncIO_, value, mask, timeout_);
140 virtual asynStatus
write(epicsUInt32 value, epicsUInt32 mask){
141 return pasynUInt32DigitalSyncIO->write(pasynUserSyncIO_, value, mask, timeout_);
146 virtual asynStatus
setInterrupt(epicsUInt32 mask, interruptReason reason) {
147 return pasynUInt32DigitalSyncIO->setInterrupt(pasynUserSyncIO_, mask, reason, timeout_);
152 return pasynUInt32DigitalSyncIO->clearInterrupt(pasynUserSyncIO_, mask, timeout_);
157 virtual asynStatus
getInterrupt(epicsUInt32 *mask, interruptReason reason) {
158 return pasynUInt32DigitalSyncIO->getInterrupt(pasynUserSyncIO_, mask, reason, timeout_);
164 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
165 pCallback,
this, mask, &interruptPvt_);
168 asynUInt32Digital *pInterface_;
182 :
asynPortClient(portName, addr, asynFloat64Type, drvInfo, timeout) {
183 pInterface_ = (asynFloat64 *)pasynInterface_->pinterface;
184 if (pasynFloat64SyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
185 throw std::runtime_error(std::string(
"pasynFloat64SyncIO->connect failed"));
189 pasynFloat64SyncIO->disconnect(pasynUserSyncIO_);
193 virtual asynStatus
read(epicsFloat64 *value) {
194 return pasynFloat64SyncIO->read(pasynUserSyncIO_, value, timeout_);
198 virtual asynStatus
write(epicsFloat64 value) {
199 return pasynFloat64SyncIO->write(pasynUserSyncIO_, value, timeout_);
204 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
205 pCallback,
this, &interruptPvt_);
208 asynFloat64 *pInterface_;
222 :
asynPortClient(portName, addr, asynOctetType, drvInfo, timeout) {
223 pInterface_ = (asynOctet *)pasynInterface_->pinterface;
224 if (pasynOctetSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
225 throw std::runtime_error(std::string(
"pasynOctetSyncIO->connect failed"));
229 pasynOctetSyncIO->disconnect(pasynUserSyncIO_);
235 virtual asynStatus
write(
const char *buffer,
size_t bufferLen,
size_t *nActual) {
236 return pasynOctetSyncIO->write(pasynUserSyncIO_, buffer, bufferLen, timeout_, nActual);
243 virtual asynStatus
read(
char *buffer,
size_t bufferLen,
size_t *nActual,
int *eomReason) {
244 return pasynOctetSyncIO->read(pasynUserSyncIO_, buffer, bufferLen, timeout_, nActual, eomReason);
254 virtual asynStatus
writeRead(
const char *writeBuffer,
size_t writeBufferLen,
char *readBuffer,
size_t readBufferLen,
255 size_t *nBytesOut,
size_t *nBytesIn,
int *eomReason) {
256 return pasynOctetSyncIO->writeRead(pasynUserSyncIO_, writeBuffer, writeBufferLen, readBuffer, readBufferLen,
257 timeout_, nBytesOut, nBytesIn, eomReason);
261 return pasynOctetSyncIO->flush(pasynUserSyncIO_);
267 return pasynOctetSyncIO->setInputEos(pasynUserSyncIO_, eos, eosLen);
273 virtual asynStatus
getInputEos(
char *eos,
int eosSize,
int *eosLen) {
274 return pasynOctetSyncIO->getInputEos(pasynUserSyncIO_, eos, eosSize, eosLen);
280 return pasynOctetSyncIO->setOutputEos(pasynUserSyncIO_, eos, eosLen);
287 return pasynOctetSyncIO->getOutputEos(pasynUserSyncIO_, eos, eosSize, eosLen);
292 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
293 pCallback,
this, &interruptPvt_);
296 asynOctet *pInterface_;
310 :
asynPortClient(portName, addr, asynInt8ArrayType, drvInfo, timeout) {
311 pInterface_ = (asynInt8Array *)pasynInterface_->pinterface;
312 if (pasynInt8ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
313 throw std::runtime_error(std::string(
"pasynInt8ArraySyncIO->connect failed"));
317 pasynInt8ArraySyncIO->disconnect(pasynUserSyncIO_);
323 virtual asynStatus
read(epicsInt8 *value,
size_t nElements,
size_t *nIn) {
324 return pasynInt8ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
329 virtual asynStatus
write(epicsInt8 *value,
size_t nElements) {
330 return pasynInt8ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
335 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
336 pCallback,
this, &interruptPvt_);
339 asynInt8Array *pInterface_;
353 :
asynPortClient(portName, addr, asynInt16ArrayType, drvInfo, timeout) {
354 pInterface_ = (asynInt16Array *)pasynInterface_->pinterface;
355 if (pasynInt16ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
356 throw std::runtime_error(std::string(
"pasynInt16ArraySyncIO->connect failed"));
360 pasynInt16ArraySyncIO->disconnect(pasynUserSyncIO_);
366 virtual asynStatus
read(epicsInt16 *value,
size_t nElements,
size_t *nIn) {
367 return pasynInt16ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
372 virtual asynStatus
write(epicsInt16 *value,
size_t nElements) {
373 return pasynInt16ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
378 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
379 pCallback,
this, &interruptPvt_);
382 asynInt16Array *pInterface_;
396 :
asynPortClient(portName, addr, asynInt32ArrayType, drvInfo, timeout) {
397 pInterface_ = (asynInt32Array *)pasynInterface_->pinterface;
398 if (pasynInt32ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
399 throw std::runtime_error(std::string(
"pasynInt32ArraySyncIO->connect failed"));
403 pasynInt32ArraySyncIO->disconnect(pasynUserSyncIO_);
409 virtual asynStatus
read(epicsInt32 *value,
size_t nElements,
size_t *nIn) {
410 return pasynInt32ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
415 virtual asynStatus
write(epicsInt32 *value,
size_t nElements) {
416 return pasynInt32ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
421 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
422 pCallback,
this, &interruptPvt_);
425 asynInt32Array *pInterface_;
439 :
asynPortClient(portName, addr, asynFloat32ArrayType, drvInfo, timeout) {
440 pInterface_ = (asynFloat32Array *)pasynInterface_->pinterface;
441 if (pasynFloat32ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
442 throw std::runtime_error(std::string(
"pasynFloat64ArraySyncIO->connect failed"));
446 pasynFloat32ArraySyncIO->disconnect(pasynUserSyncIO_);
452 virtual asynStatus
read(epicsFloat32 *value,
size_t nElements,
size_t *nIn) {
453 return pasynFloat32ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
458 virtual asynStatus
write(epicsFloat32 *value,
size_t nElements) {
459 return pasynFloat32ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
464 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
465 pCallback,
this, &interruptPvt_);
468 asynFloat32Array *pInterface_;
482 :
asynPortClient(portName, addr, asynFloat64ArrayType, drvInfo, timeout) {
483 pInterface_ = (asynFloat64Array *)pasynInterface_->pinterface;
484 if (pasynFloat64ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
485 throw std::runtime_error(std::string(
"pasynFloat64ArraySyncIO->connect failed"));
489 pasynFloat64ArraySyncIO->disconnect(pasynUserSyncIO_);
495 virtual asynStatus
read(epicsFloat64 *value,
size_t nElements,
size_t *nIn) {
496 return pasynFloat64ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
501 virtual asynStatus
write(epicsFloat64 *value,
size_t nElements) {
502 return pasynFloat64ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
507 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
508 pCallback,
this, &interruptPvt_);
511 asynFloat64Array *pInterface_;
525 :
asynPortClient(portName, addr, asynGenericPointerType, drvInfo, timeout) {
526 pInterface_ = (asynGenericPointer *)pasynInterface_->pinterface;
527 if (pasynGenericPointerSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
528 throw std::runtime_error(std::string(
"pasynGenericPointerSyncIO->connect failed"));
532 pasynGenericPointerSyncIO->disconnect(pasynUserSyncIO_);
536 virtual asynStatus
read(
void *pointer) {
537 return pasynGenericPointerSyncIO->read(pasynUserSyncIO_, pointer, timeout_);
541 virtual asynStatus
write(
void *pointer) {
542 return pasynGenericPointerSyncIO->write(pasynUserSyncIO_, pointer, timeout_);
547 return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
548 pCallback,
this, &interruptPvt_);
551 asynGenericPointer *pInterface_;
565 :
asynPortClient(portName, addr, asynOptionType, drvInfo, timeout) {
566 pInterface_ = (asynOption *)pasynInterface_->pinterface;
567 if (pasynOptionSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
568 throw std::runtime_error(std::string(
"pasynOptionSyncIO->connect failed"));
572 pasynOptionSyncIO->disconnect(pasynUserSyncIO_);
578 virtual asynStatus
getOption(
const char *key,
char *value,
int maxChars) {
579 return pasynOptionSyncIO->getOption(pasynUserSyncIO_, key, value, maxChars, timeout_);
584 virtual asynStatus
setOption(
const char *key,
const char *value) {
585 return pasynOptionSyncIO->setOption(pasynUserSyncIO_, key, value, timeout_);
588 asynOption *pInterface_;
602 :
asynPortClient(portName, addr, asynEnumType, drvInfo, timeout) {
603 pInterface_ = (asynEnum *)pasynInterface_->pinterface;
604 if (pasynEnumSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
605 throw std::runtime_error(std::string(
"pasynEnumSyncIO->connect failed"));
609 pasynEnumSyncIO->disconnect(pasynUserSyncIO_);
617 virtual asynStatus
read(
char *strings[],
int values[],
int severities[],
size_t nElements,
size_t *nIn) {
618 return pasynEnumSyncIO->read(pasynUserSyncIO_, strings, values, severities, nElements, nIn, timeout_);
625 virtual asynStatus
write(
char *strings[],
int values[],
int severities[],
size_t nElements) {
626 return pasynEnumSyncIO->write(pasynUserSyncIO_, strings, values, severities, nElements, timeout_);
629 asynEnum *pInterface_;
643 :
asynPortClient(portName, addr, asynCommonType, drvInfo, timeout) {
644 pInterface_ = (asynCommon *)pasynInterface_->pinterface;
645 if (pasynCommonSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
646 throw std::runtime_error(std::string(
"pasynCommonSyncIO->connect failed"));
650 pasynCommonSyncIO->disconnect(pasynUserSyncIO_);
655 virtual void report(FILE *fp,
int details) {
656 pasynCommonSyncIO->report(pasynUserSyncIO_, fp, details);
660 return pasynCommonSyncIO->connectDevice(pasynUserSyncIO_);
664 return pasynCommonSyncIO->disconnectDevice(pasynUserSyncIO_);
667 asynCommon *pInterface_;
Class for asyn port clients to communicate on the asynCommon interface.
Definition: asynPortClient.h:634
virtual asynStatus getOption(const char *key, char *value, int maxChars)
Get an option from the port driver.
Definition: asynPortClient.h:578
asynUInt32DigitalClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynUInt32DigitalClient class.
Definition: asynPortClient.h:121
int addr_
Definition: asynPortClient.h:55
virtual asynStatus read(epicsFloat32 *value, size_t nElements, size_t *nIn)
Reads an epicsFloat32 array from the port driver.
Definition: asynPortClient.h:452
Class for asyn port clients to communicate on the asynInt32 interface.
Definition: asynPortClient.h:64
virtual asynStatus write(epicsInt32 *value, size_t nElements)
Writes an epicsInt32 array to the port driver.
Definition: asynPortClient.h:415
Class for asyn port clients to communicate on the asynInt16Array interface.
Definition: asynPortClient.h:344
virtual asynStatus read(epicsFloat64 *value, size_t nElements, size_t *nIn)
Reads an epicsFloat64 array from the port driver.
Definition: asynPortClient.h:495
virtual asynStatus read(epicsInt16 *value, size_t nElements, size_t *nIn)
Reads an epicsInt16 array from the port driver.
Definition: asynPortClient.h:366
void setTimeout(double timeout)
Definition: asynPortClient.h:46
virtual asynStatus write(epicsFloat64 *value, size_t nElements)
Writes an epicsFloat64 array to the port driver.
Definition: asynPortClient.h:501
virtual asynStatus registerInterruptUser(interruptCallbackInt32Array pCallback)
Registers an interruptCallbackInt32Array function that the driver will call when there is a new value...
Definition: asynPortClient.h:420
virtual asynStatus getInterrupt(epicsUInt32 *mask, interruptReason reason)
Gets the current interrupt mask for the specified reason from the driver.
Definition: asynPortClient.h:157
virtual asynStatus registerInterruptUser(interruptCallbackFloat64 pCallback)
Registers an interruptCallbackFloat64 function that the driver will call when there is a new value...
Definition: asynPortClient.h:203
virtual asynStatus disconnect()
Calls the disconnect method in the driver disconnects from the port device.
Definition: asynPortClient.h:663
virtual ~asynInt32ArrayClient()
Destructor for asynInt32Array class.
Definition: asynPortClient.h:402
virtual ~asynGenericPointerClient()
Destructor for asynGenericPointer class.
Definition: asynPortClient.h:531
virtual ~asynInt32Client()
Destructor for asynInt32Client class.
Definition: asynPortClient.h:79
virtual asynStatus write(epicsInt16 *value, size_t nElements)
Writes an epicsInt16 array to the port driver.
Definition: asynPortClient.h:372
Class for asyn port clients to communicate on the asynInt8Array interface.
Definition: asynPortClient.h:301
virtual asynStatus registerInterruptUser(interruptCallbackInt16Array pCallback)
Registers an interruptCallbackInt16Array function that the driver will call when there is a new value...
Definition: asynPortClient.h:377
char * drvInfo_
Definition: asynPortClient.h:57
Class for asyn port clients to communicate on the asynFloat32Array interface.
Definition: asynPortClient.h:430
Class for asyn port clients to communicate on the asynInt32Array interface.
Definition: asynPortClient.h:387
virtual void report(FILE *fp, int details)
Calls the report method in the driver.
Definition: asynPortClient.h:655
virtual asynStatus registerInterruptUser(interruptCallbackFloat64Array pCallback)
Registers an interruptCallbackFloat64Array function that the driver will call when there is a new val...
Definition: asynPortClient.h:506
char * portName_
Definition: asynPortClient.h:54
virtual asynStatus getOutputEos(char *eos, int eosSize, int *eosLen)
Gets the output end-of-string terminator from the driver.
Definition: asynPortClient.h:286
asynFloat32ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynFloat32Array class.
Definition: asynPortClient.h:438
virtual ~asynUInt32DigitalClient()
Destructor for asynInt32Client class.
Definition: asynPortClient.h:128
virtual asynStatus read(epicsFloat64 *value)
Reads an epicsFloat64 value from the port driver.
Definition: asynPortClient.h:193
asynInt8ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynInt8Array class.
Definition: asynPortClient.h:309
virtual ~asynEnumClient()
Destructor for asynEnum class.
Definition: asynPortClient.h:608
virtual asynStatus registerInterruptUser(interruptCallbackOctet pCallback)
Registers an interruptCallbackOctet function that the driver will call when there is a new value...
Definition: asynPortClient.h:291
virtual asynStatus write(epicsUInt32 value, epicsUInt32 mask)
Writes an epicsUInt32 value to the port driver.
Definition: asynPortClient.h:140
Class for asyn port clients to communicate on the asynEnum interface.
Definition: asynPortClient.h:593
Class for asyn port clients to communicate on the asynFloat64Array interface.
Definition: asynPortClient.h:473
Class for asyn port clients to communicate on the asynGenericPointer interface.
Definition: asynPortClient.h:516
virtual asynStatus read(epicsInt32 *value)
Reads an epicsInt32 value from the port driver.
Definition: asynPortClient.h:86
virtual asynStatus read(epicsUInt32 *value, epicsUInt32 mask)
Reads an epicsUInt32 value from the port driver.
Definition: asynPortClient.h:134
virtual asynStatus connect()
Calls the connect method in the driver which attempts to connect to the port device.
Definition: asynPortClient.h:659
virtual asynStatus write(void *pointer)
Writes a generic pointer to the port driver.
Definition: asynPortClient.h:541
asynInterface * pasynInterface_
Definition: asynPortClient.h:52
virtual asynStatus read(epicsInt32 *value, size_t nElements, size_t *nIn)
Reads an epicsInt32 array from the port driver.
Definition: asynPortClient.h:409
virtual ~asynOctetClient()
Destructor for asynOctetClient class.
Definition: asynPortClient.h:228
virtual asynStatus setOption(const char *key, const char *value)
Sets an option in the port driver.
Definition: asynPortClient.h:584
asynInt32Client(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynInt32Client class.
Definition: asynPortClient.h:72
virtual ~asynFloat64ArrayClient()
Destructor for asynFloat64Array class.
Definition: asynPortClient.h:488
virtual ~asynOptionClient()
Destructor for asynOption class.
Definition: asynPortClient.h:571
void * interruptPvt_
Definition: asynPortClient.h:59
virtual asynStatus registerInterruptUser(interruptCallbackUInt32Digital pCallback, epicsUInt32 mask)
Registers an interruptCallbackUInt32Digital function that the driver will call when there is a new va...
Definition: asynPortClient.h:163
asynEnumClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynEnum class.
Definition: asynPortClient.h:601
asynUser * pasynUserSyncIO_
Definition: asynPortClient.h:51
virtual ~asynFloat32ArrayClient()
Destructor for asynFloat32Array class.
Definition: asynPortClient.h:445
virtual asynStatus registerInterruptUser(interruptCallbackInt8Array pCallback)
Registers an interruptCallbackInt8Array function that the driver will call when there is a new value...
Definition: asynPortClient.h:334
virtual asynStatus registerInterruptUser(interruptCallbackInt32 pCallback)
Registers an interruptCallbackInt32 function that the driver will call when there is a new value...
Definition: asynPortClient.h:102
virtual ~asynInt16ArrayClient()
Destructor for asynInt16Array class.
Definition: asynPortClient.h:359
Base class for asyn port clients; handles most of the bookkeeping for writing an asyn port client wit...
Definition: asynPortClient.h:42
Class for asyn port clients to communicate on the asynFloat64 interface.
Definition: asynPortClient.h:173
asynFloat64ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynFloat64Array class.
Definition: asynPortClient.h:481
Class for asyn port clients to communicate on the asynUInt32Digital interface.
Definition: asynPortClient.h:113
virtual asynStatus writeRead(const char *writeBuffer, size_t writeBufferLen, char *readBuffer, size_t readBufferLen, size_t *nBytesOut, size_t *nBytesIn, int *eomReason)
Writes a char buffer to the port driver and reads the response as an atomic operation.
Definition: asynPortClient.h:254
virtual asynStatus write(epicsInt32 value)
Writes an epicsInt32 value to the port driver.
Definition: asynPortClient.h:91
asynInt32ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynInt32Array class.
Definition: asynPortClient.h:395
virtual asynStatus read(epicsInt8 *value, size_t nElements, size_t *nIn)
Reads an epicsInt8 array from the port driver.
Definition: asynPortClient.h:323
asynGenericPointerClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynGenericPointer class.
Definition: asynPortClient.h:524
virtual asynStatus write(const char *buffer, size_t bufferLen, size_t *nActual)
Writes a char buffer to the port driver.
Definition: asynPortClient.h:235
virtual ~asynCommonClient()
Destructor for asynCommon class.
Definition: asynPortClient.h:649
virtual asynStatus getInputEos(char *eos, int eosSize, int *eosLen)
Gets the input end-of-string terminator from the driver.
Definition: asynPortClient.h:273
double timeout_
Definition: asynPortClient.h:53
virtual ~asynInt8ArrayClient()
Destructor for asynInt8Array class.
Definition: asynPortClient.h:316
asynOptionClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynOption class.
Definition: asynPortClient.h:564
virtual asynStatus write(char *strings[], int values[], int severities[], size_t nElements)
Writes enum strings, values, and severities to the port driver.
Definition: asynPortClient.h:625
asynUser * pasynUser_
Definition: asynPortClient.h:50
virtual asynStatus setInputEos(const char *eos, int eosLen)
Sets the input end-of-string terminator in the driver.
Definition: asynPortClient.h:266
virtual asynStatus registerInterruptUser(interruptCallbackGenericPointer pCallback)
Registers an interruptCallbackGenericPointer function that the driver will call when there is a new v...
Definition: asynPortClient.h:546
virtual asynStatus write(epicsFloat32 *value, size_t nElements)
Writes an epicsFloat32 array to the port driver.
Definition: asynPortClient.h:458
virtual asynStatus read(void *pointer)
Reads an generic pointer from the port driver.
Definition: asynPortClient.h:536
asynOctetClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynOctetClient class.
Definition: asynPortClient.h:221
asynCommonClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynCommon class.
Definition: asynPortClient.h:642
virtual asynStatus write(epicsFloat64 value)
Writes an epicsFloat64 value to the port driver.
Definition: asynPortClient.h:198
virtual ~asynFloat64Client()
Destructor for asynFloat64Client class.
Definition: asynPortClient.h:188
char * asynInterfaceType_
Definition: asynPortClient.h:56
#define DEFAULT_TIMEOUT
Definition: asynPortClient.h:37
asynInt16ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynInt16Array class.
Definition: asynPortClient.h:352
virtual asynStatus setInterrupt(epicsUInt32 mask, interruptReason reason)
Sets the interrupt mask for the specified interrupt reason in the driver.
Definition: asynPortClient.h:146
virtual asynStatus flush()
Flushes the input buffer in the port driver.
Definition: asynPortClient.h:260
virtual asynStatus read(char *strings[], int values[], int severities[], size_t nElements, size_t *nIn)
Reads enum strings, values, and severities from the port driver.
Definition: asynPortClient.h:617
virtual asynStatus write(epicsInt8 *value, size_t nElements)
Writes an epicsInt8 array to the port driver.
Definition: asynPortClient.h:329
virtual asynStatus registerInterruptUser(interruptCallbackFloat32Array pCallback)
Registers an interruptCallbackFloat32Array function that the driver will call when there is a new val...
Definition: asynPortClient.h:463
Class for asyn port clients to communicate on the asynOctet interface.
Definition: asynPortClient.h:213
Class for asyn port clients to communicate on the asynOption interface.
Definition: asynPortClient.h:556
asynFloat64Client(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
Constructor for asynFloat64Client class.
Definition: asynPortClient.h:181
virtual asynStatus getBounds(epicsInt32 *low, epicsInt32 *high)
Returns the lower and upper limits of the range of values from the port driver.
Definition: asynPortClient.h:97
void * drvPvt
Definition: asynPortClient.h:58
virtual asynStatus clearInterrupt(epicsUInt32 mask)
Clears the interrupt mask in the driver.
Definition: asynPortClient.h:151
virtual asynStatus setOutputEos(const char *eos, int eosLen)
Sets the output end-of-string terminator in the driver.
Definition: asynPortClient.h:279
virtual asynStatus read(char *buffer, size_t bufferLen, size_t *nActual, int *eomReason)
Reads a char buffer from the port driver.
Definition: asynPortClient.h:243