Added interpose driver from DLS
Added a low-level interpose driver to allow usage of stream devices.
This commit is contained in:
975
src/pmacAsynIPPort.c
Normal file
975
src/pmacAsynIPPort.c
Normal file
@@ -0,0 +1,975 @@
|
||||
/*
|
||||
NOTES
|
||||
|
||||
This driver is an asyn interpose driver intended for use with pmacAsynMotor
|
||||
to allow communication over ethernet to a PMAC.
|
||||
|
||||
*** Ensure I3=2 and I6=1 on the PMAC before using this driver. ***
|
||||
|
||||
This driver supports sending ascii commands to the PMAC over asyn IP and
|
||||
obtaining the response. The driver uses the PMAC ethernet packets
|
||||
VR_PMAC_GETRESPONSE, VR_PMAC_READREADY and VR_PMAC_GETBUFFER to send commands
|
||||
and get responses. The PMAC may send responses in several different formats.
|
||||
1) PMAC ascii command responses for single/multiple commands (e.g. I113 I114
|
||||
I130 I131 I133) are in an ACK terminated form as follows (CR seperates the
|
||||
cmd responses): data<CR(13)>data<CR(13)>data<CR(13)><ACK(6)> 2) PMAC error
|
||||
responses to ascii commands ARE NOT ACK terminated as follows:
|
||||
<BELL(7)>ERRxxx<CR(13)>
|
||||
3) PMAC may also return the following:
|
||||
<STX(2)>data<CR(13)>
|
||||
|
||||
This driver can send ctrl commands (ctrl B/C/F/G/P/V) to the pmac (using
|
||||
VR_CTRL_REPONSE packet) however because the resulting response data is not
|
||||
terminated as above the driver does not know when all the response data has
|
||||
been received. The response data will therefore only be returned after the
|
||||
asynUser.timeout has expired.
|
||||
|
||||
This driver does NOT support large buffer transfers (VR_PMAC_WRITEBUFFER,
|
||||
VR_FWDOWNLOAD) or set/get of DPRAM (VR_PMAC_SETMEM etc) or changing comms
|
||||
setup (VR_IPADDRESS, VR_PMAC_PORT)
|
||||
|
||||
|
||||
REVISION HISTORY
|
||||
|
||||
10 Aug 07 - Pete Leicester - Diamond Light Source
|
||||
Modified to handle responses other than those ending in <ACK> (e.g. errors) -
|
||||
No longer used asyn EOS.
|
||||
|
||||
9 Aug 07 - Pete Leicester - Diamond Light Source
|
||||
Initial version reliant on asyn EOS to return <ACK> terminated responses.
|
||||
|
||||
2 Feb 09 - Matthew Pearson - Diamond Light Source
|
||||
Ported to work with Asyn 4-10. Still compiles with pre Asyn4-10 versions but
|
||||
does not work. Also added new config function, pmacAsynIPPortConfigureEos(),
|
||||
to be used when disabling low level EOS handling in the Asyn IP layer. This
|
||||
new function should be used with Asyn 4-10 and above (it is not compatible
|
||||
with Asyn 4-9).
|
||||
|
||||
10 Apr 25 - Stefan Mathis - Paul Scherrer Institut
|
||||
Adjusted the driver to the requirements of SINQ:
|
||||
- Added a lot of comments, removed the predecessor of
|
||||
pmacAsynIPPortConfigureEos() since SINQ doesn't need it (see comment above)
|
||||
- Removed the call to `pmacFlush` from `flushItOctet`: We want to flush the
|
||||
communication buffer on the IOC side before each communication, but we do not
|
||||
want to flush the PMAC controller itself, since this stalls the controller for
|
||||
10 ms everytime (see Turbo PMAC User Manual, p. 414). Instead, a PV was added in
|
||||
the higher level `turboPmac` driver to manually call the `pmacFlush` function.
|
||||
*/
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <cantProceed.h>
|
||||
#include <epicsAssert.h>
|
||||
#include <epicsStdio.h>
|
||||
#include <epicsString.h>
|
||||
#include <iocsh.h>
|
||||
#include <osiSock.h>
|
||||
|
||||
#include "asynDriver.h"
|
||||
#include "asynInt32.h"
|
||||
#include "asynInterposeEos.h"
|
||||
#include "asynOctet.h"
|
||||
#include "drvAsynIPPort.h"
|
||||
#include "epicsThread.h"
|
||||
#include "pmacAsynIPPort.h"
|
||||
#include <epicsExport.h>
|
||||
|
||||
#define ETHERNET_DATA_SIZE 1492
|
||||
#define MAX_BUFFER_SIZE 2097152
|
||||
#define INPUT_SIZE \
|
||||
(ETHERNET_DATA_SIZE + 1) /* +1 to allow space to add terminating ACK */
|
||||
#define STX '\2'
|
||||
#define CTRLB '\2'
|
||||
#define CTRLC '\3'
|
||||
#define ACK '\6'
|
||||
#define CTRLF '\6'
|
||||
#define BELL '\7'
|
||||
#define CTRLG '\7'
|
||||
#define CTRLP '\16'
|
||||
#define CTRLV '\22'
|
||||
#define CTRLX '\24'
|
||||
|
||||
/* PMAC ethernet command structure */
|
||||
#pragma pack(1)
|
||||
typedef struct tagEthernetCmd {
|
||||
unsigned char RequestType;
|
||||
unsigned char Request;
|
||||
unsigned short wValue;
|
||||
unsigned short wIndex;
|
||||
unsigned short wLength; /* length of bData */
|
||||
unsigned char bData[ETHERNET_DATA_SIZE];
|
||||
} ethernetCmd;
|
||||
#pragma pack()
|
||||
|
||||
#define ETHERNET_CMD_HEADER (sizeof(ethernetCmd) - ETHERNET_DATA_SIZE)
|
||||
|
||||
/* PMAC ethernet commands - RequestType field */
|
||||
#define VR_UPLOAD 0xC0
|
||||
#define VR_DOWNLOAD 0x40
|
||||
|
||||
/* PMAC ethernet commands - Request field */
|
||||
#define VR_PMAC_SENDLINE 0xB0
|
||||
#define VR_PMAC_GETLINE 0xB1
|
||||
#define VR_PMAC_FLUSH 0xB3
|
||||
#define VR_PMAC_GETMEM 0xB4
|
||||
#define VR_PMAC_SETMEN 0xB5
|
||||
#define VR_PMAC_SETBIT 0xBA
|
||||
#define VR_PMAC_SETBITS 0xBB
|
||||
#define VR_PMAC_PORT 0xBE
|
||||
#define VR_PMAC_GETRESPONSE 0xBF
|
||||
#define VR_PMAC_READREADY 0xC2
|
||||
#define VR_CTRL_RESPONSE 0xC4
|
||||
#define VR_PMAC_GETBUFFER 0xC5
|
||||
#define VR_PMAC_WRITEBUFFER 0xC6
|
||||
#define VR_PMAC_WRITEERROR 0xC7
|
||||
#define VR_FWDOWNLOAD 0xCB
|
||||
#define VR_IPADDRESS 0xE0
|
||||
|
||||
/* PMAC control character commands (VR_CTRL_RESPONSE cmd) */
|
||||
static char ctrlCommands[] = {CTRLB, CTRLC, CTRLF, CTRLG, CTRLP, CTRLV};
|
||||
|
||||
/**
|
||||
* @brief PMAC_specific equivalent of the ioPvt struct from
|
||||
* asyn/interfaces/asynOctetSyncIo.c
|
||||
*
|
||||
*/
|
||||
typedef struct pmacPvt {
|
||||
char *portName;
|
||||
int addr;
|
||||
asynInterface int32Interface;
|
||||
asynInt32 *pint32; /* The methods we're overriding */
|
||||
void *int32Pvt;
|
||||
asynInterface octetInterface;
|
||||
asynOctet *poctet; /* The methods we're overriding */
|
||||
void *octetPvt;
|
||||
asynUser *pasynUser; /* For connect/disconnect reporting */
|
||||
ethernetCmd *poutCmd;
|
||||
ethernetCmd *pinCmd;
|
||||
char *inBuf;
|
||||
unsigned int inBufHead;
|
||||
unsigned int inBufTail;
|
||||
} pmacPvt;
|
||||
|
||||
/*
|
||||
Notes on asyn
|
||||
use asynUser.timeout to specify I/O request timeouts in seconds
|
||||
asynStatus may return asynSuccess(0),asynTimeout(1),asynOverflow(2) or
|
||||
asynError(3) eomReason may return ASYN_EOM_CNT (1:Request count reached),
|
||||
ASYN_EOM_EOS (2:End of String detected), ASYN_EOM_END (4:End indicator
|
||||
detected) asynError indicates that asynUser.errorMessage has been populated
|
||||
by epicsSnprintf().
|
||||
*/
|
||||
|
||||
/* Connect/disconnect handling */
|
||||
static void pmacInExceptionHandler(asynUser *pasynUser,
|
||||
asynException exception);
|
||||
|
||||
// =============================================================================
|
||||
|
||||
/* Declare asynInt32 here, and assign functions later on
|
||||
(compatible with both Asyn 4-10 and pre 4-10 versions).*/
|
||||
static asynInt32 int32;
|
||||
|
||||
/* Declare asynInt32 methods (they are defined down below) */
|
||||
static asynStatus writeInt32(void *drvPvt, asynUser *pasynUser,
|
||||
epicsInt32 value);
|
||||
static asynStatus readInt32(void *drvPvt, asynUser *pasynUser,
|
||||
epicsInt32 *value);
|
||||
static asynStatus getBoundsInt32(void *drvPvt, asynUser *pasynUser,
|
||||
epicsInt32 *low, epicsInt32 *high);
|
||||
static asynStatus registerInterruptUserInt32(void *drvPvt, asynUser *pasynUser,
|
||||
interruptCallbackInt32 callback,
|
||||
void *userPvt,
|
||||
void **registrarPvt);
|
||||
static asynStatus cancelInterruptUserInt32(void *drvPvt, asynUser *pasynUser,
|
||||
void *registrarPvt);
|
||||
|
||||
// =============================================================================
|
||||
|
||||
/* Declare asynOctet here, and assign functions later on
|
||||
(compatible with both Asyn 4-10 and pre 4-10 versions).*/
|
||||
static asynOctet octet;
|
||||
|
||||
/* Declare asynOctet methods (they are defined down below) */
|
||||
static asynStatus writeItOctet(void *drvPvt, asynUser *pasynUser,
|
||||
const char *data, size_t numchars,
|
||||
size_t *nbytesTransfered);
|
||||
static asynStatus readItOctet(void *drvPvt, asynUser *pasynUser, char *data,
|
||||
size_t maxchars, size_t *nbytesTransfered,
|
||||
int *eomReason);
|
||||
static asynStatus flushItOctet(void *drvPvt, asynUser *pasynUser);
|
||||
static asynStatus registerInterruptUserOctet(void *drvPvt, asynUser *pasynUser,
|
||||
interruptCallbackOctet callback,
|
||||
void *userPvt,
|
||||
void **registrarPvt);
|
||||
static asynStatus cancelInterruptUserOctet(void *drvPvt, asynUser *pasynUser,
|
||||
void *registrarPvt);
|
||||
static asynStatus setInputEosOctet(void *drvPvt, asynUser *pasynUser,
|
||||
const char *eos, int eoslen);
|
||||
static asynStatus getInputEosOctet(void *drvPvt, asynUser *pasynUser, char *eos,
|
||||
int eossize, int *eoslen);
|
||||
static asynStatus setOutputEosOctet(void *drvPvt, asynUser *pasynUser,
|
||||
const char *eos, int eoslen);
|
||||
static asynStatus getOutputEosOctet(void *drvPvt, asynUser *pasynUser,
|
||||
char *eos, int eossize, int *eoslen);
|
||||
|
||||
// =============================================================================
|
||||
|
||||
// Declare PMAC-specific functions (they are defined down below)
|
||||
|
||||
static asynStatus readResponse(pmacPvt *pPmacPvt, asynUser *pasynUser,
|
||||
size_t maxchars, size_t *nbytesTransfered,
|
||||
int *eomReason);
|
||||
static int pmacReadReady(pmacPvt *pPmacPvt, asynUser *pasynUser);
|
||||
static int pmacFlush(pmacPvt *pPmacPvt, asynUser *pasynUser);
|
||||
static asynStatus sendPmacGetBuffer(pmacPvt *pPmacPvt, asynUser *pasynUser,
|
||||
size_t maxchars, size_t *nbytesTransfered);
|
||||
|
||||
// =============================================================================
|
||||
|
||||
epicsShareFunc int pmacAsynIPPortConfigure(const char *portName,
|
||||
const char *hostInfo) {
|
||||
asynStatus status = asynSuccess;
|
||||
asynInterface *int32LowerLevelInterface = NULL;
|
||||
asynInterface *octetLowerLevelInterface = NULL;
|
||||
asynUser *pasynUser = NULL;
|
||||
size_t len = 0;
|
||||
|
||||
/*
|
||||
The asyn adress is always set to 0. This is taken verbatim from the DLS
|
||||
source code
|
||||
(https://github.com/DiamondLightSource/pmac/blob/afe81f8bb9179c3a20eff351f30bc6cfd1539ad9/pmacApp/pmacAsynIPPortSrc/pmacAsynIPPort.c#L192)
|
||||
*/
|
||||
int addr = 0;
|
||||
|
||||
/*
|
||||
This is the generic "parent" function of this function which is also
|
||||
exported in the IOC shell and used for drivers which don't use a specialized
|
||||
interpose layer.
|
||||
*/
|
||||
if ((status = drvAsynIPPortConfigure(portName, hostInfo, 0, 0, 1)) != 0) {
|
||||
printf(
|
||||
"pmacAsynIPPortConfigure: error from drvAsynIPPortConfigure. Port: "
|
||||
"%s\n",
|
||||
portName);
|
||||
}
|
||||
|
||||
/*
|
||||
Assign specialized versions of the methods from
|
||||
asyn/interfaces/asynInt32SyncIo.c
|
||||
*/
|
||||
int32.write = writeInt32;
|
||||
int32.read = readInt32;
|
||||
int32.getBounds = getBoundsInt32;
|
||||
int32.registerInterruptUser = registerInterruptUserInt32;
|
||||
int32.cancelInterruptUser = cancelInterruptUserInt32;
|
||||
|
||||
/*
|
||||
Assign specialized versions of the methods from
|
||||
asyn/interfaces/asynOctetSyncIO.c
|
||||
*/
|
||||
octet.write = writeItOctet;
|
||||
octet.read = readItOctet;
|
||||
octet.flush = flushItOctet;
|
||||
octet.setInputEos = setInputEosOctet;
|
||||
octet.setOutputEos = setOutputEosOctet;
|
||||
octet.getInputEos = getInputEosOctet;
|
||||
octet.getOutputEos = getOutputEosOctet;
|
||||
octet.registerInterruptUser = registerInterruptUserOctet;
|
||||
octet.cancelInterruptUser = cancelInterruptUserOctet;
|
||||
|
||||
len = sizeof(pmacPvt) + strlen(portName) + 1;
|
||||
pmacPvt *pPmacPvt = callocMustSucceed(
|
||||
1, len,
|
||||
"calloc pPmacPvt error in pmacAsynIPPort::pmacAsynIPPortConfigure.");
|
||||
|
||||
pPmacPvt->portName = (char *)(pPmacPvt + 1);
|
||||
|
||||
strcpy(pPmacPvt->portName, portName);
|
||||
pPmacPvt->addr = addr;
|
||||
|
||||
pPmacPvt->int32Interface.interfaceType = asynInt32Type;
|
||||
pPmacPvt->int32Interface.pinterface = &int32;
|
||||
pPmacPvt->int32Interface.drvPvt = pPmacPvt;
|
||||
|
||||
status = pasynInt32Base->initialize(pPmacPvt->portName,
|
||||
&pPmacPvt->int32Interface);
|
||||
if (status != asynSuccess) {
|
||||
printf("pmacAsynIPPortConfigure: Can't register int32.\n");
|
||||
pasynManager->freeAsynUser(pasynUser);
|
||||
free(pPmacPvt);
|
||||
return -1;
|
||||
}
|
||||
|
||||
pPmacPvt->octetInterface.interfaceType = asynOctetType;
|
||||
pPmacPvt->octetInterface.pinterface = &octet;
|
||||
pPmacPvt->octetInterface.drvPvt = pPmacPvt;
|
||||
|
||||
// We don't need to initialize the octet interface, since the interface type
|
||||
// asynOctetType has already been initialized in drvAsynIPPortConfigure(..).
|
||||
|
||||
pasynUser = pasynManager->createAsynUser(0, 0);
|
||||
pPmacPvt->pasynUser = pasynUser;
|
||||
pPmacPvt->pasynUser->userPvt = pPmacPvt;
|
||||
|
||||
// In case connecting to the given IP port fails, clean up the memory
|
||||
status = pasynManager->connectDevice(pasynUser, portName, addr);
|
||||
if (status != asynSuccess) {
|
||||
printf("pmacAsynIPPortConfigure: %s connectDevice failed\n", portName);
|
||||
pasynManager->freeAsynUser(pasynUser);
|
||||
free(pPmacPvt);
|
||||
return -1;
|
||||
}
|
||||
|
||||
status =
|
||||
pasynManager->exceptionCallbackAdd(pasynUser, pmacInExceptionHandler);
|
||||
if (status != asynSuccess) {
|
||||
printf("pmacAsynIPPortConfigure: %s exceptionCallbackAdd failed\n",
|
||||
portName);
|
||||
pasynManager->freeAsynUser(pasynUser);
|
||||
free(pPmacPvt);
|
||||
return -1;
|
||||
}
|
||||
|
||||
status = pasynManager->interposeInterface(
|
||||
portName, addr, &pPmacPvt->int32Interface, &(int32LowerLevelInterface));
|
||||
if (status != asynSuccess) {
|
||||
printf("pmacAsynIPPortConfigure: %s interposeInterface failed\n",
|
||||
portName);
|
||||
pasynManager->exceptionCallbackRemove(pasynUser);
|
||||
pasynManager->freeAsynUser(pasynUser);
|
||||
free(pPmacPvt);
|
||||
return -1;
|
||||
}
|
||||
pPmacPvt->pint32 = (asynInt32 *)int32LowerLevelInterface->pinterface;
|
||||
pPmacPvt->int32Pvt = int32LowerLevelInterface->drvPvt;
|
||||
|
||||
status = pasynManager->interposeInterface(
|
||||
portName, addr, &pPmacPvt->octetInterface, &(octetLowerLevelInterface));
|
||||
if (status != asynSuccess) {
|
||||
printf("pmacAsynIPPortConfigure: %s interposeInterface failed\n",
|
||||
portName);
|
||||
pasynManager->exceptionCallbackRemove(pasynUser);
|
||||
pasynManager->freeAsynUser(pasynUser);
|
||||
free(pPmacPvt);
|
||||
return -1;
|
||||
}
|
||||
pPmacPvt->poctet = (asynOctet *)octetLowerLevelInterface->pinterface;
|
||||
pPmacPvt->octetPvt = octetLowerLevelInterface->drvPvt;
|
||||
|
||||
pPmacPvt->poutCmd = callocMustSucceed(
|
||||
1, sizeof(ethernetCmd),
|
||||
"calloc poutCmd error in pmacAsynIPPort::pmacAsynIPPortCommon().");
|
||||
pPmacPvt->pinCmd = callocMustSucceed(
|
||||
1, sizeof(ethernetCmd),
|
||||
"calloc pinCmd error in pmacAsynIPPort::pmacAsynIPPortCommon().");
|
||||
|
||||
pPmacPvt->inBuf = callocMustSucceed(
|
||||
1, MAX_BUFFER_SIZE,
|
||||
"calloc inBuf error in pmacAsynIPPort::pmacAsynIPPortCommon().");
|
||||
|
||||
pPmacPvt->inBufHead = 0;
|
||||
pPmacPvt->inBufTail = 0;
|
||||
|
||||
// Interpose EOS handling layer, above the PMAC IP layer.
|
||||
asynInterposeEosConfig(portName, addr, 1, 1);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
static void pmacInExceptionHandler(asynUser *pasynUser,
|
||||
asynException exception) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)pasynUser->userPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacInExceptionHandler\n");
|
||||
|
||||
if (exception == asynExceptionConnect) {
|
||||
pPmacPvt->inBufHead = 0;
|
||||
pPmacPvt->inBufTail = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Read reponse data from PMAC into buffer pmacPvt.inBuf. If there is no data
|
||||
in the asyn buffer then issue pmac GETBUFFER command to get any outstanding
|
||||
data still on the PMAC.
|
||||
*/
|
||||
static asynStatus readResponse(pmacPvt *pPmacPvt, asynUser *pasynUser,
|
||||
size_t maxchars, size_t *nbytesTransfered,
|
||||
int *eomReason) {
|
||||
asynStatus status = asynSuccess;
|
||||
size_t thisRead = 0;
|
||||
*nbytesTransfered = 0;
|
||||
if (maxchars > INPUT_SIZE)
|
||||
maxchars = INPUT_SIZE;
|
||||
|
||||
asynPrint(
|
||||
pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::readResponse. Performing pPmacPvt->poctet->read().\n");
|
||||
|
||||
status =
|
||||
pPmacPvt->poctet->read(pPmacPvt->octetPvt, pasynUser, pPmacPvt->inBuf,
|
||||
maxchars, &thisRead, eomReason);
|
||||
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"%s readResponse1 maxchars=%zd, thisRead=%zd, eomReason=%d, "
|
||||
"status=%u\n",
|
||||
pPmacPvt->portName, maxchars, thisRead, *eomReason, status);
|
||||
if (status == asynTimeout && thisRead == 0 && pasynUser->timeout > 0) {
|
||||
/* failed to read as many characters as required into the input buffer,
|
||||
check for more response data on the PMAC */
|
||||
if (pmacReadReady(pPmacPvt, pasynUser)) {
|
||||
|
||||
status = sendPmacGetBuffer(pPmacPvt, pasynUser, maxchars,
|
||||
nbytesTransfered);
|
||||
asynPrintIO(pasynUser, ASYN_TRACE_FLOW, (char *)pPmacPvt->pinCmd,
|
||||
ETHERNET_CMD_HEADER, "%s write GETBUFFER\n",
|
||||
pPmacPvt->portName);
|
||||
|
||||
/* We have nothing to return at the moment so read again */
|
||||
status = pPmacPvt->poctet->read(pPmacPvt->octetPvt, pasynUser,
|
||||
pPmacPvt->inBuf, maxchars,
|
||||
&thisRead, eomReason);
|
||||
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"%s readResponse2 maxchars=%zd, thisRead=%zd, "
|
||||
"eomReason=%d, status=%u\n",
|
||||
pPmacPvt->portName, maxchars, thisRead, *eomReason,
|
||||
status);
|
||||
}
|
||||
}
|
||||
|
||||
if (thisRead > 0) {
|
||||
if (status == asynTimeout)
|
||||
status = asynSuccess;
|
||||
*nbytesTransfered = thisRead;
|
||||
pPmacPvt->inBufTail = 0;
|
||||
pPmacPvt->inBufHead = thisRead;
|
||||
}
|
||||
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::readResponse. END\n");
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/*
|
||||
Send ReadReady command to PMAC to discover if there is any data to read from
|
||||
it. Returns: 0 - no data available 1 - data available
|
||||
*/
|
||||
static int pmacReadReady(pmacPvt *pPmacPvt, asynUser *pasynUser) {
|
||||
ethernetCmd cmd;
|
||||
char data[2] = {0};
|
||||
asynStatus status;
|
||||
size_t thisRead = 0;
|
||||
size_t nbytesTransfered = 0;
|
||||
int eomReason = 0;
|
||||
int retval = 0;
|
||||
|
||||
cmd.RequestType = VR_UPLOAD;
|
||||
cmd.Request = VR_PMAC_READREADY;
|
||||
cmd.wValue = 0;
|
||||
cmd.wIndex = 0;
|
||||
cmd.wLength = htons(2);
|
||||
|
||||
status =
|
||||
pPmacPvt->poctet->write(pPmacPvt->octetPvt, pasynUser, (char *)&cmd,
|
||||
ETHERNET_CMD_HEADER, &nbytesTransfered);
|
||||
|
||||
if (status != asynSuccess) {
|
||||
asynPrintIO(pasynUser, ASYN_TRACE_ERROR, (char *)&cmd,
|
||||
ETHERNET_CMD_HEADER, "%s write pmacReadReady fail\n",
|
||||
pPmacPvt->portName);
|
||||
}
|
||||
|
||||
status = pPmacPvt->poctet->read(pPmacPvt->octetPvt, pasynUser, data, 2,
|
||||
&thisRead, &eomReason);
|
||||
|
||||
if (status == asynSuccess) {
|
||||
if (thisRead == 2 && data[0] != 0) {
|
||||
retval = 1;
|
||||
}
|
||||
asynPrintIO(pasynUser, ASYN_TRACE_FLOW, data, thisRead,
|
||||
"%s read pmacReadReady OK thisRead=%zd\n",
|
||||
pPmacPvt->portName, thisRead);
|
||||
} else {
|
||||
asynPrint(pasynUser, ASYN_TRACE_ERROR,
|
||||
"%s read pmacReadReady failed status=%d,retval=%d",
|
||||
pPmacPvt->portName, status, retval);
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Flush the PMAC communication buffer
|
||||
*
|
||||
Send a Flush command to PMAC and wait for confirmation ctrlX to be returned
|
||||
according to the Turbo PMAC user manual, p. 414 Returns: 0 - failed 1 - success
|
||||
|
||||
* @param pPmacPvt
|
||||
* @param pasynUser
|
||||
* @return int
|
||||
*/
|
||||
static int pmacFlush(pmacPvt *pPmacPvt, asynUser *pasynUser) {
|
||||
|
||||
ethernetCmd cmd;
|
||||
char data[2];
|
||||
asynStatus status = asynSuccess;
|
||||
size_t thisRead;
|
||||
size_t nbytesTransfered = 0;
|
||||
int eomReason = 0;
|
||||
int retval = 0;
|
||||
|
||||
cmd.RequestType = VR_DOWNLOAD;
|
||||
cmd.Request = VR_PMAC_FLUSH;
|
||||
cmd.wValue = 0;
|
||||
cmd.wIndex = 0;
|
||||
cmd.wLength = 0;
|
||||
|
||||
status =
|
||||
pPmacPvt->poctet->write(pPmacPvt->octetPvt, pasynUser, (char *)&cmd,
|
||||
ETHERNET_CMD_HEADER, &nbytesTransfered);
|
||||
|
||||
if (status != asynSuccess) {
|
||||
asynPrintIO(pasynUser, ASYN_TRACE_ERROR, (char *)&cmd,
|
||||
ETHERNET_CMD_HEADER, "%s write pmacFlush fail\n",
|
||||
pPmacPvt->portName);
|
||||
}
|
||||
|
||||
/* read flush acknowledgement character */
|
||||
/* NB we don't check what the character is (manual sais ctrlX, we get 0x40
|
||||
* i.e.VR_DOWNLOAD) */
|
||||
status = pPmacPvt->poctet->read(pPmacPvt->octetPvt, pasynUser, data, 1,
|
||||
&thisRead, &eomReason);
|
||||
|
||||
if (status == asynSuccess) {
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s read pmacFlush OK\n",
|
||||
pPmacPvt->portName);
|
||||
retval = 1;
|
||||
} else {
|
||||
asynPrint(pasynUser, ASYN_TRACE_ERROR,
|
||||
"%s read pmacFlush failed - thisRead=%zd, eomReason=%d, "
|
||||
"status=%d\n",
|
||||
pPmacPvt->portName, thisRead, eomReason, status);
|
||||
}
|
||||
|
||||
pPmacPvt->inBufTail = 0;
|
||||
pPmacPvt->inBufHead = 0;
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
static asynStatus sendPmacGetBuffer(pmacPvt *pPmacPvt, asynUser *pasynUser,
|
||||
size_t maxchars, size_t *nbytesTransfered) {
|
||||
asynStatus status = 0;
|
||||
ethernetCmd *inCmd = NULL;
|
||||
|
||||
inCmd = pPmacPvt->pinCmd;
|
||||
inCmd->RequestType = VR_UPLOAD;
|
||||
inCmd->Request = VR_PMAC_GETBUFFER;
|
||||
inCmd->wValue = 0;
|
||||
inCmd->wIndex = 0;
|
||||
inCmd->wLength = htons(maxchars);
|
||||
status = pPmacPvt->poctet->write(pPmacPvt->octetPvt, pasynUser,
|
||||
(char *)pPmacPvt->pinCmd,
|
||||
ETHERNET_CMD_HEADER, nbytesTransfered);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/*
|
||||
Implementation of asynInt32 methods
|
||||
Most of these implementations just redirect to the corresponding implementation
|
||||
in asyn/interfaces/asynInt32Base.c
|
||||
*/
|
||||
// =============================================================================
|
||||
|
||||
static asynStatus writeInt32(void *drvPvt, asynUser *pasynUser,
|
||||
epicsInt32 value) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::writeInt32\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
if (pasynUser->reason == FLUSH_HARDWARE) {
|
||||
/*
|
||||
According to the Turbo PMAC user manual, p. 414:
|
||||
0 - failed 1 - success
|
||||
*/
|
||||
if (pmacFlush(pPmacPvt, pasynUser) == 1) {
|
||||
return asynSuccess;
|
||||
} else {
|
||||
return asynError;
|
||||
}
|
||||
} else {
|
||||
return pPmacPvt->pint32->write(pPmacPvt->int32Pvt, pasynUser, value);
|
||||
}
|
||||
}
|
||||
|
||||
static asynStatus readInt32(void *drvPvt, asynUser *pasynUser,
|
||||
epicsInt32 *value) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::readInt32\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->pint32->read(pPmacPvt->int32Pvt, pasynUser, value);
|
||||
}
|
||||
|
||||
static asynStatus getBoundsInt32(void *drvPvt, asynUser *pasynUser,
|
||||
epicsInt32 *low, epicsInt32 *high) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::getBoundsInt32\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->pint32->getBounds(pPmacPvt->int32Pvt, pasynUser, low,
|
||||
high);
|
||||
}
|
||||
|
||||
static asynStatus registerInterruptUserInt32(void *drvPvt, asynUser *pasynUser,
|
||||
interruptCallbackInt32 callback,
|
||||
void *userPvt,
|
||||
void **registrarPvt) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::registerInterruptUserInt32\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->pint32->registerInterruptUser(
|
||||
pPmacPvt->int32Pvt, pasynUser, callback, userPvt, registrarPvt);
|
||||
}
|
||||
|
||||
static asynStatus cancelInterruptUserInt32(void *drvPvt, asynUser *pasynUser,
|
||||
void *registrarPvt) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::cancelInterruptUserInt32\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->pint32->cancelInterruptUser(pPmacPvt->int32Pvt, pasynUser,
|
||||
registrarPvt);
|
||||
}
|
||||
|
||||
/*
|
||||
Implementation of asynOctet methods
|
||||
Most of these implementations just redirect to the corresponding implementation
|
||||
in asyn/interfaces/asynOctetBase.c
|
||||
*/
|
||||
// =============================================================================
|
||||
|
||||
/* This function sends either a ascii string command to the PMAC using
|
||||
VR_PMAC_GETRESPONSE or a single control character (ctrl B/C/F/G/P/V) using
|
||||
VR_CTRL_RESPONSE
|
||||
*/
|
||||
static asynStatus writeItOctet(void *drvPvt, asynUser *pasynUser,
|
||||
const char *data, size_t numchars,
|
||||
size_t *nbytesTransfered) {
|
||||
asynStatus status;
|
||||
ethernetCmd *outCmd;
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
size_t nbytesActual = 0;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::writeItOctet\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
/* NB currently we assume control characters arrive as individual
|
||||
characters/calls to this routine. Idealy we should probably scan the data
|
||||
buffer for control commands and do PMAC_GETRESPONSE and CTRL_RESPONSE
|
||||
commands as necessary, */
|
||||
outCmd = pPmacPvt->poutCmd;
|
||||
if (numchars == 1 && strchr(ctrlCommands, data[0])) {
|
||||
outCmd->RequestType = VR_UPLOAD;
|
||||
outCmd->Request = VR_CTRL_RESPONSE;
|
||||
outCmd->wValue = data[0];
|
||||
outCmd->wIndex = 0;
|
||||
outCmd->wLength = htons(0);
|
||||
status = pPmacPvt->poctet->write(pPmacPvt->octetPvt, pasynUser,
|
||||
(char *)pPmacPvt->poutCmd,
|
||||
ETHERNET_CMD_HEADER, &nbytesActual);
|
||||
*nbytesTransfered =
|
||||
(nbytesActual == ETHERNET_CMD_HEADER) ? numchars : 0;
|
||||
} else {
|
||||
if (numchars > ETHERNET_DATA_SIZE) {
|
||||
/* NB large data should probably be sent using PMAC_WRITEBUFFER
|
||||
* which isnt implemented yet - for the moment just truncate */
|
||||
numchars = ETHERNET_DATA_SIZE;
|
||||
asynPrint(pasynUser, ASYN_TRACE_ERROR,
|
||||
"writeItOctet - ERROR TRUNCATED\n");
|
||||
}
|
||||
|
||||
/*
|
||||
The message protocol of the turboPmac used at PSI looks as follows (all
|
||||
characters immediately following each other without a newline):
|
||||
0x40 (ASCII value of @) -> Request for download
|
||||
0xBF (ASCII value of ¿) -> Select mode "get_response"
|
||||
0x00 (ASCII value of 0)
|
||||
0x00 (ASCII value of 0)
|
||||
0x00 (ASCII value of 0)
|
||||
0x00 (ASCII value of 0)
|
||||
0x00 (ASCII value of 0)
|
||||
[message length in network byte order] -> Use the htons function for
|
||||
this value [Actual message] It is not necessary to append a terminator,
|
||||
since this protocol encodes the message length at the beginning. See
|
||||
Turbo PMAC User Manual, page 418 in VR_PMAC_GETRESPONSE x0D (ASCII value
|
||||
of carriage return) -> The controller needs a carriage return at the end
|
||||
of a "send" command (a command were we transmit data via
|
||||
=). For "request" commands (e.g. read status or position), this is not
|
||||
necessary, but it doesn't hurt either, therefore we always add a
|
||||
carriage return.
|
||||
|
||||
The message has to be build manually into the buffer fullCommand, since
|
||||
it contains NULL terminators in its middle, therefore the string
|
||||
manipulation methods of C don't work.
|
||||
*/
|
||||
outCmd->RequestType = VR_DOWNLOAD;
|
||||
outCmd->Request = VR_PMAC_GETRESPONSE;
|
||||
outCmd->wValue = 0;
|
||||
outCmd->wIndex = 0;
|
||||
outCmd->wLength = htons(numchars);
|
||||
memcpy(outCmd->bData, data, numchars);
|
||||
status = pPmacPvt->poctet->write(
|
||||
pPmacPvt->octetPvt, pasynUser, (char *)pPmacPvt->poutCmd,
|
||||
numchars + ETHERNET_CMD_HEADER, &nbytesActual);
|
||||
*nbytesTransfered = (nbytesActual > ETHERNET_CMD_HEADER)
|
||||
? (nbytesActual - ETHERNET_CMD_HEADER)
|
||||
: 0;
|
||||
}
|
||||
|
||||
asynPrintIO(pasynUser, ASYN_TRACE_FLOW, (char *)pPmacPvt->poutCmd,
|
||||
numchars + ETHERNET_CMD_HEADER, "%s writeItOctet\n",
|
||||
pPmacPvt->portName);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/*
|
||||
This function reads data using read() into a local buffer and then look for
|
||||
message terminating characters and returns a complete response (or times
|
||||
out), adding on ACK if neccessary. The PMAC command response may be any of
|
||||
the following:- data<CR>data<CR>....data<CR><ACK> <BELL>data<CR> e.g. an
|
||||
error <BELL>ERRxxx<CR> <STX>data<CR> (NB asyn EOS only allows one message
|
||||
terminator to be specified. We add on ACK for the EOS layer above.)
|
||||
*/
|
||||
static asynStatus readItOctet(void *drvPvt, asynUser *pasynUser, char *data,
|
||||
size_t maxchars, size_t *nbytesTransfered,
|
||||
int *eomReason) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynStatus status = asynSuccess;
|
||||
size_t thisRead = 0;
|
||||
size_t nRead = 0;
|
||||
int bell = 0;
|
||||
int initialRead = 1;
|
||||
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::readItOctet. START\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
if (maxchars > 0) {
|
||||
for (;;) {
|
||||
if ((pPmacPvt->inBufTail != pPmacPvt->inBufHead)) {
|
||||
*data = pPmacPvt->inBuf[pPmacPvt->inBufTail++];
|
||||
if (*data == BELL || *data == STX)
|
||||
bell = 1;
|
||||
if (*data == '\r' && bell) {
|
||||
/* <BELL>xxxxxx<CR> or <STX>xxxxx<CR> received - its
|
||||
* probably an error response (<BELL>ERRxxx<CR>) - assume
|
||||
* there is no more response data to come */
|
||||
nRead++; /* make sure the <CR> is passed to the client app
|
||||
*/
|
||||
/*Add on ACK, because that's what we expect to be EOS in EOS
|
||||
* interpose layer.*/
|
||||
if ((nRead + 1) > maxchars) {
|
||||
/*If maxchars is reached overwrite <CR> with ACK, so
|
||||
* that no more reads will be done from EOS layer.*/
|
||||
*data = ACK;
|
||||
} else {
|
||||
data++;
|
||||
nRead++;
|
||||
*data = ACK;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (*data == ACK || *data == '\n') {
|
||||
/* <ACK> or <LF> received - assume there is no more response
|
||||
* data to come */
|
||||
/* If <LF>, replace with an ACK.*/
|
||||
if (*data == '\n') {
|
||||
*data = ACK;
|
||||
}
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"Message was terminated with ACK in "
|
||||
"pmacAsynIPPort::readItOctet.\n");
|
||||
/*Pass ACK up to Asyn EOS handling layer.*/
|
||||
data++;
|
||||
nRead++;
|
||||
break;
|
||||
}
|
||||
data++;
|
||||
nRead++;
|
||||
if (nRead >= maxchars)
|
||||
break;
|
||||
continue;
|
||||
}
|
||||
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::readItOctet. Calling readResponse().\n");
|
||||
if (!initialRead) {
|
||||
if (pmacReadReady(pPmacPvt, pasynUser)) {
|
||||
status = sendPmacGetBuffer(pPmacPvt, pasynUser, maxchars,
|
||||
nbytesTransfered);
|
||||
}
|
||||
}
|
||||
status = readResponse(pPmacPvt, pasynUser, maxchars - nRead,
|
||||
&thisRead, eomReason);
|
||||
initialRead = 0;
|
||||
if (status != asynSuccess || thisRead == 0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
*nbytesTransfered = nRead;
|
||||
|
||||
asynPrintIO(
|
||||
pasynUser, ASYN_TRACE_FLOW, data, *nbytesTransfered,
|
||||
"%s pmacAsynIPPort readItOctet nbytesTransfered=%zd, eomReason=%d, "
|
||||
"status=%d\n",
|
||||
pPmacPvt->portName, *nbytesTransfered, *eomReason, status);
|
||||
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::readItOctet. END\n");
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
static asynStatus flushItOctet(void *drvPvt, asynUser *pasynUser) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynStatus status;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::flushItOctet\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
/*
|
||||
See changelog at the file header: We do not want to flush the controller
|
||||
during "normal" operation, since this stalls the controller.
|
||||
|
||||
pmacFlush(pPmacPvt, pasynUser);
|
||||
*/
|
||||
|
||||
status = pPmacPvt->poctet->flush(pPmacPvt->octetPvt, pasynUser);
|
||||
return status;
|
||||
}
|
||||
|
||||
static asynStatus registerInterruptUserOctet(void *drvPvt, asynUser *pasynUser,
|
||||
interruptCallbackOctet callback,
|
||||
void *userPvt,
|
||||
void **registrarPvt) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::registerInterruptUserOctet\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->poctet->registerInterruptUser(
|
||||
pPmacPvt->octetPvt, pasynUser, callback, userPvt, registrarPvt);
|
||||
}
|
||||
|
||||
static asynStatus cancelInterruptUserOctet(void *drvPvt, asynUser *pasynUser,
|
||||
void *registrarPvt) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::cancelInterruptUserOctet\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->poctet->cancelInterruptUser(pPmacPvt->octetPvt, pasynUser,
|
||||
registrarPvt);
|
||||
}
|
||||
|
||||
static asynStatus setInputEosOctet(void *drvPvt, asynUser *pasynUser,
|
||||
const char *eos, int eoslen) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::setInputEosOctet\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->poctet->setInputEos(pPmacPvt->octetPvt, pasynUser, eos,
|
||||
eoslen);
|
||||
}
|
||||
|
||||
static asynStatus getInputEosOctet(void *drvPvt, asynUser *pasynUser, char *eos,
|
||||
int eossize, int *eoslen) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW, "pmacAsynIPPort::getInputEosOctet\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->poctet->getInputEos(pPmacPvt->octetPvt, pasynUser, eos,
|
||||
eossize, eoslen);
|
||||
}
|
||||
|
||||
static asynStatus setOutputEosOctet(void *drvPvt, asynUser *pasynUser,
|
||||
const char *eos, int eoslen) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::setOutputEosOctet\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->poctet->setOutputEos(pPmacPvt->octetPvt, pasynUser, eos,
|
||||
eoslen);
|
||||
}
|
||||
|
||||
static asynStatus getOutputEosOctet(void *drvPvt, asynUser *pasynUser,
|
||||
char *eos, int eossize, int *eoslen) {
|
||||
pmacPvt *pPmacPvt = (pmacPvt *)drvPvt;
|
||||
asynPrint(pasynUser, ASYN_TRACE_FLOW,
|
||||
"pmacAsynIPPort::getOutputEosOctet\n");
|
||||
|
||||
// Check that the given pointer is not NULL
|
||||
assert(pPmacPvt);
|
||||
|
||||
return pPmacPvt->poctet->getOutputEos(pPmacPvt->octetPvt, pasynUser, eos,
|
||||
eossize, eoslen);
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
|
||||
/* register pmacAsynIPPortConfigure*/
|
||||
static const iocshArg pmacAsynIPPortConfigureArg0 = {"portName",
|
||||
iocshArgString};
|
||||
static const iocshArg pmacAsynIPPortConfigureArg1 = {"hostInfo",
|
||||
iocshArgString};
|
||||
static const iocshArg *pmacAsynIPPortConfigureArgs[] = {
|
||||
&pmacAsynIPPortConfigureArg0, &pmacAsynIPPortConfigureArg1};
|
||||
static const iocshFuncDef pmacAsynIPPortConfigFuncDef = {
|
||||
"pmacAsynIPPortConfigure", 2, pmacAsynIPPortConfigureArgs, ""};
|
||||
static void pmacAsynIPPortConfigureCallFunc(const iocshArgBuf *args) {
|
||||
pmacAsynIPPortConfigure(args[0].sval, args[1].sval);
|
||||
}
|
||||
|
||||
static void pmacAsynIPPortRegister(void) {
|
||||
static int firstTime = 1;
|
||||
if (firstTime) {
|
||||
firstTime = 0;
|
||||
iocshRegister(&pmacAsynIPPortConfigFuncDef,
|
||||
pmacAsynIPPortConfigureCallFunc);
|
||||
}
|
||||
}
|
||||
epicsExportRegistrar(pmacAsynIPPortRegister);
|
||||
Reference in New Issue
Block a user