Fixed endless loop when communication times out and added

diagnostics.

.gitlab-ci.yml

@@ -47,11 +47,11 @@ build_module:
     - sed -i 's/ARCH_FILTER=.*/ARCH_FILTER=linux%/' Makefile
     - echo "LIBVERSION=${CI_COMMIT_TAG:-0.0.1}" >> Makefile
     - make install
-    - cp -rT "/ioc/modules/pmacv3/$(ls -U /ioc/modules/pmacv3/ | head -1)" "./pmacv3-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}"
+    - cp -rT "/ioc/modules/turboPmac/$(ls -U /ioc/modules/turboPmac/ | head -1)" "./turboPmac-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}"
   artifacts:
-    name: "pmacv3-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}"
+    name: "turboPmac-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}"
     paths:
-      - "pmacv3-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}/*"
+      - "turboPmac-${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA}/*"
     expire_in: 1 week
   when: always
   tags:

Makefile

@@ -1,30 +1,35 @@
 # Use the PSI build system
 include /ioc/tools/driver.makefile
 
-MODULE=pmacv3
+MODULE=turboPmac
 BUILDCLASSES=Linux
 EPICS_VERSIONS=7.0.7
 ARCH_FILTER=RHEL%
 
 # Additional module dependencies
-REQUIRED+=asynMotor
+REQUIRED+=motorBase
 REQUIRED+=sinqMotor
 
+# Specify the version of motorBase we want to build against
+motorBase_VERSION=7.2.2
+
 # Specify the version of sinqMotor we want to build against
-sinqMotor_VERSION=0.6.3
+sinqMotor_VERSION=0.14
 
 # These headers allow to depend on this library for derived drivers.
-HEADERS += src/pmacv3Axis.h
-HEADERS += src/pmacv3Controller.h
+HEADERS += src/pmacAsynIPPort.h
+HEADERS += src/turboPmacAxis.h
+HEADERS += src/turboPmacController.h
 
 # Source files to build
-SOURCES += src/pmacv3Axis.cpp
-SOURCES += src/pmacv3Controller.cpp
+SOURCES += src/pmacAsynIPPort.c
+SOURCES += src/turboPmacAxis.cpp
+SOURCES += src/turboPmacController.cpp
 
 # Store the record files
-TEMPLATES += db/pmacv3.db
+TEMPLATES += db/turboPmac.db
 
 # This file registers the motor-specific functions in the IOC shell.
-DBDS += src/pmacv3.dbd
+DBDS += src/turboPmac.dbd
 
-USR_CFLAGS += -Wall -Wextra -Weffc++ -Wunused-result # -Werror
+USR_CFLAGS += -Wall -Wextra -Weffc++ -Wunused-result -Werror # -Wpedantic // Does not work because EPICS macros trigger warnings

README.md

@@ -1,42 +1,72 @@
-# pmacv3
+# turboPmac
+
+## <span style="color:red">Please read the documentation of sinqMotor first: https://git.psi.ch/sinq-epics-modules/sinqmotor</span>
 
 ## Overview
 
-This is a driver for the pmacV3 motion controller with the SINQ communication protocol. It is based on the sinqMotor shared library (https://git.psi.ch/sinq-epics-modules/sinqmotor). The header files contain detailed documentation for all public functions. The headers themselves are exported when building the library to allow other drivers to depend on this one.
+This is a driver for the Turbo PMAC motion controller with the SINQ communication protocol. It is based on the sinqMotor shared library (https://git.psi.ch/sinq-epics-modules/sinqmotor). The header files contain detailed documentation for all public functions. The headers themselves are exported when building the library to allow other drivers to depend on this one.
 
 ## User guide
 
-This driver is a standard sinqMotor-derived driver and does not need any specific configuration. For the general configuration, please see https://git.psi.ch/sinq-epics-modules/sinqmotor/-/blob/main/README.md.
+This driver is a standard sinqMotor-derived which however uses a special low level IP Port driver (`pmacAsynIPPortConfigure`) instead of the standard `drvAsynIPPortConfigure`. For the general configuration, please see https://git.psi.ch/sinq-epics-modules/sinqmotor/-/blob/main/README.md.
 
-The folder "utils" contains utility scripts for working with pmac motor controllers:
+The folder "utils" contains utility scripts for working with pmac motor controllers. To read their manual, run the scripts without any arguments.
 - writeRead.py: Allows sending commands to and receiving commands from a pmac controller over an ethernet connection.
-- analyzeTcpDump: This script takes a tcpdump as an input and 
+- analyzeTcpDump.py: Parse the TCP communication between an IOC and a MCU and format it into a dictionary. "demo.py" shows how this data can be easily visualized for analysis.
+
+
+
+### IOC startup script
+
+turboPmac exports the following IOC shell functions:
+- `turboPmacController`: Create a new controller object.
+- `turboPmacAxis`: Create a new axis object.
+
+The full turboPmacX.cmd file looks like this:
+
+```
+# Define the name of the controller and the corresponding port
+epicsEnvSet("DRIVER_PORT","turboPmacX")
+epicsEnvSet("IP_PORT","p$(DRIVER_PORT)")
+
+# Create the TCP/IP socket used to talk with the controller. The socket can be adressed from within the IOC shell via the port name.
+# We do not use the standard asyn port driver here, but a PMAC-specific one which enables the usage of StreamDevices for
+# communicating with the controller directly.
+pmacAsynIPPortConfigure("$(IP_PORT)","172.28.101.24:1025")
+
+# Create the controller object with the defined name and connect it to the socket via the port name.
+# The other parameters are as follows:
+# 8: Maximum number of axes
+# 0.05: Busy poll period in seconds
+# 1: Idle poll period in seconds
+# 1: Socket communication timeout in seconds
+turboPmacController("$(DRIVER_PORT)", "$(IP_PORT)", 8, 0.05, 1, 1);
+
+# Define some axes for the specified MCU at the given slot (1, 2 and 5). No slot may be used twice!
+turboPmacAxis("$(DRIVER_PORT)",1);
+turboPmacAxis("$(DRIVER_PORT)",2);
+turboPmacAxis("$(DRIVER_PORT)",5);
+
+# Set the number of subsequent timeouts 
+setMaxSubsequentTimeouts("$(DRIVER_PORT)", 20);
+
+# Configure the timeout frequency watchdog: A maximum of 10 timeouts are allowed in 300 seconds before an alarm message is sent.
+setThresholdComTimeout("$(DRIVER_PORT)", 300, 10);
+
+# Parametrize the EPICS record database with the substitution file named after the MCU.
+epicsEnvSet("SINQDBPATH","$(sinqMotor_DB)/sinqMotor.db")
+dbLoadTemplate("$(TOP)/$(DRIVER_PORT).substitutions", "INSTR=$(INSTR)$(DRIVER_PORT):,CONTROLLER=$(DRIVER_PORT)")
+epicsEnvSet("SINQDBPATH","$(turboPmac_DB)/turboPmac.db")
+dbLoadTemplate("$(TOP)/$(DRIVER_PORT).substitutions", "INSTR=$(INSTR)$(DRIVER_PORT):,CONTROLLER=$(DRIVER_PORT)")
+dbLoadRecords("$(sinqMotor_DB)/asynRecord.db","P=$(INSTR)$(DRIVER_PORT),PORT=$(IP_PORT)")
+```
+
+### Additional records
+
+`turboPmac` provides a variety of additional records. See `db/turboPmac.db` for the complete list and the documentation.
 
 ## Developer guide
 
-### Usage in IOC shell
-
-pmacv3 exposes the following IOC shell functions (all in pmacv3Controller.cpp):
-- `pmacv3Controller`: Create a new controller object.
-- `pmacv3Axis`: Create a new axis object.
-These functions are parametrized as follows:
-```
-pmacv3Controller(
-    "$(NAME)", # Name of the MCU, e.g. mcu1. This parameter should be provided by an environment variable.
-    "$(ASYN_PORT)", # IP-Port of the MCU. This parameter should be provided by an environment variable.
-    8, # Maximum number of axes
-    0.05, # Busy poll period in seconds
-    1, # Idle poll period in seconds
-    0.05 # Communication timeout in seconds
-    );
-```
-```
-pmacv3Axis(
-    "$(NAME)", # Name of the associated MCU, e.g. mcu1. This parameter should be provided by an environment variable.
-    1 # Index of the axis.
-    );
-```
-
 ### Versioning
 
 Please see the documentation for the module sinqMotor: https://git.psi.ch/sinq-epics-modules/sinqmotor/-/blob/main/README.md.

db/turboPmac.db

@@ -7,7 +7,7 @@ record(longout, "$(INSTR)$(M):RereadEncoder") {
     field(PINI, "NO")
 }
 
-# The pmacV3 driver reads certain configuration parameters (such as the velocity
+# The turboPmac driver reads certain configuration parameters (such as the velocity
 # and the acceleration) directly from the MCU. This reading procedure is performed
 # once at IOC startup during atFirstPoll. However, it can be triggered manually
 # by setting this record value to 1.
@@ -16,4 +16,18 @@ record(longout, "$(INSTR)$(M):ReadConfig") {
     field(DTYP, "asynInt32")
     field(OUT, "@asyn($(CONTROLLER),$(AXIS),1) READ_CONFIG")
     field(PINI, "NO")
-}
+}
+
+# PMAC controllers can be "flushed" by setting a certain bit. This empties all
+# communication buffers. Once the flush is done, the controller acknowledges
+# this by sending an echo character. This procedure can take up to 10 ms (see 
+# Turbo PMAC User Manual, p. 414) and should therefore not be done as part of
+# "normal" communications (like the original pmacAsynIPPort driver from DLS 
+# does). The SINQ driver for the Turbo PMAC controller therefore offers this PV
+# in order to manually trigger a controller flush by writing any value to this PV.
+record(longout, "$(INSTR)FlushHardware") {
+    field(DTYP, "asynInt32")
+    field(OUT, "@asyn($(CONTROLLER),$(AXIS),1) FLUSH_HARDWARE")
+    field(PINI, "NO")
+    field(VAL, "1")
+}

src/pmacAsynIPPort.c

@@ -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\n",
+                  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);

src/pmacAsynIPPort.h

@@ -0,0 +1,35 @@
+#ifndef asynInterposePmac_H
+#define asynInterposePmac_H
+
+#include <epicsExport.h>
+#include <shareLib.h>
+
+/*
+Value is chosen arbitrarily, it just needs to be unique
+*/
+#define FLUSH_HARDWARE 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * @brief Initialize a special asyn IP Port for PMAC controllers.
+ *
+ * Function that first initialises an asyn IP port and then the PMAC Asyn IP
+ * interpose layer. It is a wrapper for drvAsynIPPort::drvAsynIPPortConfigure()
+ * and pmacAsynIPPort::pmacAsynIPPortConfigureEos().
+ *
+ * @param portName The Asyn Port name string.
+ * @param hostInfo The hostname or IP address followed by IP port (eg.
+ * 172.23.243.156:1025)
+ * @return status
+ */
+epicsShareFunc int pmacAsynIPPortConfigure(const char *portName,
+                                           const char *hostInfo);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* asynInterposePmac_H */

src/pmacv3Controller.cpp

@@ -1,593 +0,0 @@
-#include "pmacv3Controller.h"
-#include "asynMotorController.h"
-#include "asynOctetSyncIO.h"
-#include "pmacv3Axis.h"
-#include <epicsExport.h>
-#include <errlog.h>
-#include <iocsh.h>
-#include <netinet/in.h>
-#include <registryFunction.h>
-#include <string.h>
-#include <unistd.h>
-
-/**
- * @brief Copy src into dst and replace all carriage returns with spaces. This
- * allows to print *dst with asynPrint.
- *
- *
- * @param dst                 Buffer for the modified string
- * @param src                 Original string
- */
-void adjustResponseForPrint(char *dst, const char *src, size_t buf_length) {
-    for (size_t i = 0; i < buf_length; i++) {
-        if (src[i] == '\r') {
-            dst[i] = ' ';
-        } else {
-            dst[i] = src[i];
-        }
-    }
-}
-
-/**
- * @brief Construct a new pmacv3Controller::pmacv3Controller object
- *
- * @param portName              See documentation of sinqController
- * @param ipPortConfigName      See documentation of sinqController
- * @param numAxes               See documentation of sinqController
- * @param movingPollPeriod      See documentation of sinqController
- * @param idlePollPeriod        See documentation of sinqController
- * @param comTimeout  Time after which a communication timeout error
- * is declared in writeRead (in seconds)
- * @param extraParams           See documentation of sinqController
- */
-pmacv3Controller::pmacv3Controller(const char *portName,
-                                   const char *ipPortConfigName, int numAxes,
-                                   double movingPollPeriod,
-                                   double idlePollPeriod, double comTimeout)
-    : sinqController(
-          portName, ipPortConfigName, numAxes, movingPollPeriod, idlePollPeriod,
-          /*
-          The following parameter library entries are added in this driver:
-          - REREAD_ENCODER_POSITION
-          - READ_CONFIG
-          */
-          NUM_PMACV3_DRIVER_PARAMS)
-
-{
-
-    // Initialization of local variables
-    asynStatus status = asynSuccess;
-
-    // Initialization of all member variables
-    lowLevelPortUser_ = nullptr;
-    comTimeout_ = comTimeout;
-
-    // =========================================================================;
-
-    /*
-    We try to connect to the port via the port name provided by the constructor.
-    If this fails, the function is terminated via exit
-    */
-    pasynOctetSyncIO->connect(ipPortConfigName, 0, &lowLevelPortUser_, NULL);
-    if (status != asynSuccess || lowLevelPortUser_ == nullptr) {
-        errlogPrintf(
-            "%s => line %d:\nFATAL ERROR (cannot connect to MCU controller).\n"
-            "Terminating IOC",
-            __PRETTY_FUNCTION__, __LINE__);
-        exit(-1);
-    }
-
-    // =========================================================================
-    // Create additional parameter library entries
-
-    status = createParam("REREAD_ENCODER_POSITION", asynParamInt32,
-                         &rereadEncoderPosition_);
-    if (status != asynSuccess) {
-        asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
-                  "%s => line %d:\nFATAL ERROR (creating a parameter failed "
-                  "with %s).\nTerminating IOC",
-                  __PRETTY_FUNCTION__, __LINE__, stringifyAsynStatus(status));
-        exit(-1);
-    }
-
-    status = createParam("READ_CONFIG", asynParamInt32, &readConfig_);
-    if (status != asynSuccess) {
-        asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
-                  "%s => line %d:\nFATAL ERROR (creating a parameter failed "
-                  "with %s).\nTerminating IOC",
-                  __PRETTY_FUNCTION__, __LINE__, stringifyAsynStatus(status));
-        exit(-1);
-    }
-
-    /*
-    Define the end-of-string of a message coming from the device to EPICS.
-    It is not necessary to append a terminator to outgoing messages, since
-    the message length is encoded in the message header in the getSetResponse
-    method.
-    */
-    const char *message_from_device =
-        "\006"; // Hex-code for ACK (acknowledge) -> Each message from the MCU
-                // is terminated by this value
-    status = pasynOctetSyncIO->setInputEos(
-        lowLevelPortUser_, message_from_device, strlen(message_from_device));
-    if (status != asynSuccess) {
-        asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
-                  "%s => line %d:\nFATAL ERROR (setting input EOS failed "
-                  "with %s).\nTerminating IOC",
-                  __PRETTY_FUNCTION__, __LINE__, stringifyAsynStatus(status));
-        pasynOctetSyncIO->disconnect(lowLevelPortUser_);
-        exit(-1);
-    }
-
-    status = callParamCallbacks();
-    if (status != asynSuccess) {
-        asynPrint(
-            this->pasynUserSelf, ASYN_TRACE_ERROR,
-            "%s => line %d:\nFATAL ERROR (executing ParamLib callbacks failed "
-            "with %s).\nTerminating IOC",
-            __PRETTY_FUNCTION__, __LINE__, stringifyAsynStatus(status));
-        pasynOctetSyncIO->disconnect(lowLevelPortUser_);
-        exit(-1);
-    }
-}
-
-/*
-Access one of the axes of the controller via the axis adress stored in asynUser.
-If the axis does not exist or is not a Axis, a nullptr is returned and an
-error is emitted.
-*/
-pmacv3Axis *pmacv3Controller::getAxis(asynUser *pasynUser) {
-    asynMotorAxis *asynAxis = asynMotorController::getAxis(pasynUser);
-    return pmacv3Controller::castToAxis(asynAxis);
-}
-
-/*
-Access one of the axes of the controller via the axis index.
-If the axis does not exist or is not a Axis, the function must return Null
-*/
-pmacv3Axis *pmacv3Controller::getAxis(int axisNo) {
-    asynMotorAxis *asynAxis = asynMotorController::getAxis(axisNo);
-    return pmacv3Controller::castToAxis(asynAxis);
-}
-
-pmacv3Axis *pmacv3Controller::castToAxis(asynMotorAxis *asynAxis) {
-
-    // =========================================================================
-
-    // If the axis slot of the pAxes_ array is empty, a nullptr must be returned
-    if (asynAxis == nullptr) {
-        return nullptr;
-    }
-
-    // Here, an error is emitted since asyn_axis is not a nullptr but also not
-    // an instance of Axis
-    pmacv3Axis *axis = dynamic_cast<pmacv3Axis *>(asynAxis);
-    if (axis == nullptr) {
-        asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
-                  "%s => line %d:\nAxis %d is not an instance of pmacv3Axis",
-                  __PRETTY_FUNCTION__, __LINE__, axis->axisNo_);
-    }
-    return axis;
-}
-
-asynStatus pmacv3Controller::writeRead(int axisNo, const char *command,
-                                       char *response,
-                                       int numExpectedResponses) {
-
-    // Definition of local variables.
-    asynStatus status = asynSuccess;
-    asynStatus pl_status = asynSuccess;
-    char fullCommand[MAXBUF_] = {0};
-    char drvMessageText[MAXBUF_] = {0};
-    char modResponse[MAXBUF_] = {0};
-    int motorStatusProblem = 0;
-    int numReceivedResponses = 0;
-
-    // Send the message and block the thread until either a response has
-    // been received or the timeout is triggered
-    int eomReason = 0; // Flag indicating why the message has ended
-
-    // Number of bytes of the outgoing message (which is command + the
-    // end-of-string terminator defined in the constructor)
-    size_t nbytesOut = 0;
-
-    // Number of bytes of the incoming message (which is response + the
-    // end-of-string terminator defined in the constructor)
-    size_t nbytesIn = 0;
-
-    // =========================================================================
-
-    pmacv3Axis *axis = getAxis(axisNo);
-    if (axis == nullptr) {
-        // We already did the error logging directly in getAxis
-        return asynError;
-    }
-
-    /*
-    The message protocol of the pmacv3 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
-
-    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.
-    */
-
-    // The entire message is equal to the command length
-    const size_t commandLength =
-        strlen(command) + 1; // +1 because of the appended /r
-    const int offset = 8;
-
-    // Positions 2 to 6 must have the value 0. Since fullCommand is initialized
-    // as an array of zeros, we don't need to set these bits manually.
-    fullCommand[0] = '\x40';
-    fullCommand[1] = '\xBF';
-    fullCommand[7] = commandLength;
-
-    snprintf((char *)fullCommand + offset, MAXBUF_ - offset, "%s\r", command);
-    asynPrint(this->pasynUserSelf, ASYN_TRACEIO_DRIVER,
-              "%s => line %d:\nSending command %s", __PRETTY_FUNCTION__,
-              __LINE__, fullCommand);
-
-    // Perform the actual writeRead
-    status = pasynOctetSyncIO->writeRead(
-        lowLevelPortUser_, fullCommand, commandLength + offset, response,
-        MAXBUF_, comTimeout_, &nbytesOut, &nbytesIn, &eomReason);
-
-    /*
-    Calculate the number of received responses by counting the number of
-    carriage returns "\r" in the response.
-    */
-    for (size_t i = 0; i < strlen(response); i++) {
-        if (response[i] == '\r') {
-            numReceivedResponses++;
-        }
-    }
-
-    /*
-    Check if we got the expected amount of responses. If we didn't, flush the
-    PMAC and try again. If that fails as well, return an error.
-    */
-    if (numExpectedResponses != numReceivedResponses) {
-        // Flush message as defined in Turbo PMAC User Manual, p. 430:
-        // \x40\xB3000
-        // VR_DOWNLOAD = \x40
-        // VR_PMAC_FLUSH = \xB3
-        char flush_msg[5] = {0};
-        flush_msg[0] = '\x40';
-        flush_msg[1] = '\xB3';
-        size_t nbytesOut = 0;
-        status = pasynOctetSyncIO->write(lowLevelPortUser_, flush_msg, 5,
-                                         comTimeout_, &nbytesOut);
-
-        // Wait after the flush so the MCU has time to prepare for the
-        // next command
-        usleep(100000);
-
-        if (status == asynSuccess) {
-            // If flushing the MCU succeded, try to send the command again
-            status = pasynOctetSyncIO->writeRead(
-                lowLevelPortUser_, fullCommand, commandLength + offset,
-                response, MAXBUF_, comTimeout_, &nbytesOut, &nbytesIn,
-                &eomReason);
-
-            // If the command returned a bad answer for the second time, give up
-            // and propagate the problem
-            numReceivedResponses = 0;
-            for (size_t i = 0; i < strlen(response); i++) {
-                if (response[i] == '\r') {
-                    numReceivedResponses++;
-                }
-            }
-
-            // Second check: If this fails, give up and propagate the error.
-            if (numExpectedResponses != numReceivedResponses) {
-
-                adjustResponseForPrint(modResponse, response, MAXBUF_);
-                asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
-                          "%s => line %d:\nUnexpected response '%s' (carriage "
-                          "returns are replaced with spaces) for command %s\n",
-                          __PRETTY_FUNCTION__, __LINE__, modResponse, command);
-                snprintf(drvMessageText, sizeof(drvMessageText),
-                         "Received unexpected response '%s' (carriage returns "
-                         "are replaced with spaces) for command %s. "
-                         "Please call the support",
-                         modResponse, command);
-                pl_status = setStringParam(motorMessageText_, drvMessageText);
-                if (pl_status != asynSuccess) {
-                    return paramLibAccessFailed(pl_status, "motorMessageText_",
-                                                __PRETTY_FUNCTION__, __LINE__);
-                }
-                status = asynError;
-            }
-        } else {
-            asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR,
-                      "%s => line %d:\nFlushing the MCU failed with %s\n",
-                      __PRETTY_FUNCTION__, __LINE__,
-                      stringifyAsynStatus(status));
-        }
-    }
-
-    // Create custom error messages for different failure modes
-    if (strlen(drvMessageText) == 0) {
-        switch (status) {
-        case asynSuccess:
-            break; // Communicate nothing
-        case asynTimeout:
-            snprintf(drvMessageText, sizeof(drvMessageText),
-                     "connection timeout for axis %d", axisNo);
-            break;
-        case asynDisconnected:
-            snprintf(drvMessageText, sizeof(drvMessageText),
-                     "axis is not connected");
-            break;
-        case asynDisabled:
-            snprintf(drvMessageText, sizeof(drvMessageText),
-                     "axis is disabled");
-            break;
-        default:
-            snprintf(drvMessageText, sizeof(drvMessageText),
-                     "Communication failed (%s)", stringifyAsynStatus(status));
-            break;
-        }
-    }
-
-    // Log the overall status (communication successfull or not)
-    if (status == asynSuccess) {
-
-        asynPrint(lowLevelPortUser_, ASYN_TRACEIO_DRIVER,
-                  "%s => line %d:\nDevice response: %s (_ are "
-                  "carriage returns)\n",
-                  __PRETTY_FUNCTION__, __LINE__, modResponse);
-        pl_status = axis->setIntegerParam(this->motorStatusCommsError_, 0);
-    } else {
-        asynPrint(lowLevelPortUser_, ASYN_TRACE_ERROR,
-                  "%s => line %d:\nCommunication failed for command %s (%s)\n",
-                  __PRETTY_FUNCTION__, __LINE__, fullCommand,
-                  stringifyAsynStatus(status));
-
-        // Check if the axis already is in an error communication mode. If it is
-        // not, upstream the error. This is done to avoid "flooding" the user
-        // with different error messages if more than one error ocurred before
-        // an error-free communication
-        pl_status =
-            getIntegerParam(axisNo, motorStatusProblem_, &motorStatusProblem);
-        if (pl_status != asynSuccess) {
-            return paramLibAccessFailed(pl_status, "motorStatusProblem_",
-                                        __PRETTY_FUNCTION__, __LINE__);
-        }
-
-        if (motorStatusProblem == 0) {
-            pl_status = axis->setStringParam(motorMessageText_, drvMessageText);
-            if (pl_status != asynSuccess) {
-                return paramLibAccessFailed(pl_status, "motorMessageText_",
-                                            __PRETTY_FUNCTION__, __LINE__);
-            }
-
-            pl_status = axis->setIntegerParam(motorStatusProblem_, 1);
-            if (pl_status != asynSuccess) {
-                return paramLibAccessFailed(pl_status, "motorStatusProblem",
-                                            __PRETTY_FUNCTION__, __LINE__);
-            }
-
-            pl_status = axis->setIntegerParam(motorStatusProblem_, 1);
-            if (pl_status != asynSuccess) {
-                return paramLibAccessFailed(pl_status, "motorStatusCommsError_",
-                                            __PRETTY_FUNCTION__, __LINE__);
-            }
-        }
-    }
-    return status;
-}
-
-asynStatus pmacv3Controller::writeInt32(asynUser *pasynUser, epicsInt32 value) {
-    int function = pasynUser->reason;
-
-    // =====================================================================
-
-    pmacv3Axis *axis = getAxis(pasynUser);
-    if (axis == nullptr) {
-        // We already did the error logging directly in getAxis
-        return asynError;
-    }
-
-    // Handle custom PVs
-    if (function == rereadEncoderPosition_) {
-        return axis->rereadEncoder();
-    } else if (function == readConfig_) {
-        return axis->atFirstPoll();
-    } else {
-        return sinqController::writeInt32(pasynUser, value);
-    }
-}
-
-asynStatus sinqController::readInt32(asynUser *pasynUser, epicsInt32 *value) {
-    // PMACs can be disabled
-    if (pasynUser->reason == motorCanDisable_) {
-        *value = 1;
-        return asynSuccess;
-    } else {
-        return asynMotorController::readInt32(pasynUser, value);
-    }
-}
-
-asynStatus pmacv3Controller::errMsgCouldNotParseResponse(
-    const char *command, const char *response, int axisNo,
-    const char *functionName, int lineNumber) {
-    char modifiedResponse[MAXBUF_] = {0};
-    adjustResponseForPrint(modifiedResponse, response, MAXBUF_);
-    return sinqController::errMsgCouldNotParseResponse(
-        command, modifiedResponse, axisNo, functionName, lineNumber);
-}
-
-/*************************************************************************************/
-/** The following functions are C-wrappers, and can be called directly from
- * iocsh */
-
-extern "C" {
-
-/*
-C wrapper for the controller constructor. Please refer to the pmacv3Controller
-constructor documentation.
-*/
-asynStatus pmacv3CreateController(const char *portName,
-                                  const char *ipPortConfigName, int numAxes,
-                                  double movingPollPeriod,
-                                  double idlePollPeriod, double comTimeout) {
-    /*
-    We create a new instance of the controller, using the "new" keyword to
-    allocate it on the heap while avoiding RAII.
-    https://github.com/epics-modules/motor/blob/master/motorApp/MotorSrc/asynMotorController.cpp
-    https://github.com/epics-modules/asyn/blob/master/asyn/asynPortDriver/asynPortDriver.cpp
-
-    The created object is registered in EPICS in its constructor and can safely
-    be "leaked" here.
-    */
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
-#pragma GCC diagnostic ignored "-Wunused-variable"
-    pmacv3Controller *pController =
-        new pmacv3Controller(portName, ipPortConfigName, numAxes,
-                             movingPollPeriod, idlePollPeriod, comTimeout);
-
-    return asynSuccess;
-}
-
-/*
-C wrapper for the axis constructor. Please refer to the pmacv3Axis constructor
-documentation. The controller is read from the portName.
-*/
-asynStatus pmacv3CreateAxis(const char *portName, int axis) {
-    pmacv3Axis *pAxis;
-
-    /*
-    findAsynPortDriver is a asyn library FFI function which uses the C ABI.
-    Therefore it returns a void pointer instead of e.g. a pointer to a
-    superclass of the controller such as asynPortDriver. Type-safe upcasting
-    via dynamic_cast is therefore not possible directly. However, we do know
-    that the void pointer is either a pointer to asynPortDriver (if a driver
-    with the specified name exists) or a nullptr. Therefore, we first do a
-    nullptr check, then a cast to asynPortDriver and lastly a (typesafe)
-    dynamic_upcast to Controller
-    https://stackoverflow.com/questions/70906749/is-there-a-safe-way-to-cast-void-to-class-pointer-in-c
-     */
-    void *ptr = findAsynPortDriver(portName);
-    if (ptr == nullptr) {
-        /*
-        We can't use asynPrint here since this macro would require us
-        to get a lowLevelPortUser_ from a pointer to an asynPortDriver.
-        However, the given pointer is a nullptr and therefore doesn't
-        have a lowLevelPortUser_! printf is an EPICS alternative which
-        works w/o that, but doesn't offer the comfort provided
-        by the asynTrace-facility
-        */
-        errlogPrintf("%s => line %d:\nPort %s not found.", __PRETTY_FUNCTION__,
-                     __LINE__, portName);
-        return asynError;
-    }
-    // Unsafe cast of the pointer to an asynPortDriver
-    asynPortDriver *apd = (asynPortDriver *)(ptr);
-
-    // Safe downcast
-    pmacv3Controller *pC = dynamic_cast<pmacv3Controller *>(apd);
-    if (pC == nullptr) {
-        errlogPrintf(
-            "%s => line %d:\ncontroller on port %s is not a pmacv3Controller.",
-            __PRETTY_FUNCTION__, __LINE__, portName);
-        return asynError;
-    }
-
-    // Prevent manipulation of the controller from other threads while we
-    // create the new axis.
-    pC->lock();
-
-    /*
-    We create a new instance of the axis, using the "new" keyword to
-    allocate it on the heap while avoiding RAII.
-    https://github.com/epics-modules/motor/blob/master/motorApp/MotorSrc/asynMotorController.cpp
-    https://github.com/epics-modules/asyn/blob/master/asyn/asynPortDriver/asynPortDriver.cpp
-
-    The created object is registered in EPICS in its constructor and can safely
-    be "leaked" here.
-    */
-#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
-#pragma GCC diagnostic ignored "-Wunused-variable"
-    pAxis = new pmacv3Axis(pC, axis);
-
-    // Allow manipulation of the controller again
-    pC->unlock();
-    return asynSuccess;
-}
-
-/*
-This is boilerplate code which is used to make the FFI functions
-CreateController and CreateAxis "known" to the IOC shell (iocsh).
-*/
-
-#ifdef vxWorks
-#else
-
-/*
-Define name and type of the arguments for the CreateController function
-in the iocsh. This is done by creating structs with the argument names and
-types and then providing "factory" functions
-(configCreateControllerCallFunc). These factory functions are used to
-register the constructors during compilation.
-*/
-static const iocshArg CreateControllerArg0 = {"Controller name (e.g. mcu1)",
-                                              iocshArgString};
-static const iocshArg CreateControllerArg1 = {"Asyn IP port name (e.g. pmcu1)",
-                                              iocshArgString};
-static const iocshArg CreateControllerArg2 = {"Number of axes", iocshArgInt};
-static const iocshArg CreateControllerArg3 = {"Moving poll rate (s)",
-                                              iocshArgDouble};
-static const iocshArg CreateControllerArg4 = {"Idle poll rate (s)",
-                                              iocshArgDouble};
-static const iocshArg CreateControllerArg5 = {"Communication timeout (s)",
-                                              iocshArgDouble};
-static const iocshArg *const CreateControllerArgs[] = {
-    &CreateControllerArg0, &CreateControllerArg1, &CreateControllerArg2,
-    &CreateControllerArg3, &CreateControllerArg4, &CreateControllerArg5};
-static const iocshFuncDef configPmacV3CreateController = {"pmacv3Controller", 6,
-                                                          CreateControllerArgs};
-static void configPmacV3CreateControllerCallFunc(const iocshArgBuf *args) {
-    pmacv3CreateController(args[0].sval, args[1].sval, args[2].ival,
-                           args[3].dval, args[4].dval, args[5].dval);
-}
-
-/*
-Same procedure as for the CreateController function, but for the axis
-itself.
-*/
-static const iocshArg CreateAxisArg0 = {"Controller name (e.g. mcu1)",
-                                        iocshArgString};
-static const iocshArg CreateAxisArg1 = {"Axis number", iocshArgInt};
-static const iocshArg *const CreateAxisArgs[] = {&CreateAxisArg0,
-                                                 &CreateAxisArg1};
-static const iocshFuncDef configPmacV3CreateAxis = {"pmacv3Axis", 2,
-                                                    CreateAxisArgs};
-static void configPmacV3CreateAxisCallFunc(const iocshArgBuf *args) {
-    pmacv3CreateAxis(args[0].sval, args[1].ival);
-}
-
-// This function is made known to EPICS in pmacv3.dbd and is called by EPICS
-// in order to register both functions in the IOC shell
-static void pmacv3Register(void) {
-    iocshRegister(&configPmacV3CreateController,
-                  configPmacV3CreateControllerCallFunc);
-    iocshRegister(&configPmacV3CreateAxis, configPmacV3CreateAxisCallFunc);
-}
-epicsExportRegistrar(pmacv3Register);
-
-#endif
-
-} // extern "C"

src/turboPmac.dbd

@@ -1,4 +1,6 @@
 #---------------------------------------------
 # SINQ specific DB definitions
 #---------------------------------------------
-registrar(pmacv3Register) 
+registrar(turboPmacControllerRegister) 
+registrar(turboPmacAxisRegister) 
+registrar(pmacAsynIPPortRegister)

src/turboPmacAxis.h

@@ -1,27 +1,28 @@
-#ifndef pmacv3AXIS_H
-#define pmacv3AXIS_H
+#ifndef turboPmacAXIS_H
+#define turboPmacAXIS_H
 #include "sinqAxis.h"
 
 // Forward declaration of the controller class to resolve the cyclic dependency
-// between C804Controller.h and C804Axis.h. See
+// between the controller and the axis .h-file. See
 // https://en.cppreference.com/w/cpp/language/class.
-class pmacv3Controller;
+class turboPmacController;
 
-class pmacv3Axis : public sinqAxis {
+class turboPmacAxis : public sinqAxis {
   public:
     /**
-     * @brief Construct a new pmacv3Axis
+     * @brief Construct a new turboPmacAxis
      *
      * @param pController         Pointer to the associated controller
      * @param axisNo              Index of the axis
      */
-    pmacv3Axis(pmacv3Controller *pController, int axisNo);
+    turboPmacAxis(turboPmacController *pController, int axisNo,
+                  bool initialize = true);
 
     /**
-     * @brief Destroy the pmacv3Axis
+     * @brief Destroy the turboPmacAxis
      *
      */
-    virtual ~pmacv3Axis();
+    virtual ~turboPmacAxis();
 
     /**
      * @brief Implementation of the `stop` function from asynMotorAxis
@@ -69,16 +70,24 @@ class pmacv3Axis : public sinqAxis {
                       double max_velocity, double acceleration);
 
     /**
-     * @brief Implementation of the `atFirstPoll` function from sinqAxis.
+     * @brief Readout of some values from the controller at IOC startup
      *
      * The following steps are performed:
      * - Read out the motor status, motor position, velocity and acceleration
      * from the MCU and store this information in the parameter library.
-     * - Set the enable PV accordint to the initial status of the axis.
+     * - Set the enable PV according to the initial status of the axis.
      *
      * @return asynStatus
      */
-    asynStatus atFirstPoll();
+    asynStatus init();
+
+    /**
+     * @brief Implementation of the `doReset` function from sinqAxis.
+     *
+     * @param on
+     * @return asynStatus
+     */
+    asynStatus doReset();
 
     /**
      * @brief Enable / disable the axis.
@@ -103,18 +112,24 @@ class pmacv3Axis : public sinqAxis {
      */
     asynStatus rereadEncoder();
 
-  protected:
-    pmacv3Controller *pC_;
+    /**
+     * @brief Interpret the error code and populate the user message accordingly
+     *
+     * @param error
+     * @param userMessage
+     * @param sizeUserMessage
+     * @return asynStatus
+     */
+    asynStatus handleError(int error, char *userMessage, int sizeUserMessage);
+
+  protected:
+    turboPmacController *pC_;
 
-    bool initial_poll_;
     bool waitForHandshake_;
     time_t timeAtHandshake_;
 
     // The axis status is used when enabling / disabling the motor
     int axisStatus_;
-
-  private:
-    friend class pmacv3Controller;
 };
 
 #endif

src/turboPmacController.cpp

@@ -0,0 +1,533 @@
+#include "turboPmacController.h"
+#include "asynInt32SyncIO.h"
+#include "asynMotorController.h"
+#include "asynOctetSyncIO.h"
+#include "pmacAsynIPPort.h"
+#include "turboPmacAxis.h"
+#include <epicsExport.h>
+#include <errlog.h>
+#include <initHooks.h>
+#include <iocsh.h>
+#include <netinet/in.h>
+#include <registryFunction.h>
+#include <string.h>
+#include <unistd.h>
+
+/**
+ * @brief Copy src into dst and replace all carriage returns with spaces. This
+ * allows to print *dst with asynPrint.
+ *
+ *
+ * @param dst                 Buffer for the modified string
+ * @param src                 Original string
+ */
+void adjustResponseForPrint(char *dst, const char *src, size_t buf_length) {
+    for (size_t i = 0; i < buf_length; i++) {
+        if (src[i] == '\r') {
+            dst[i] = ' ';
+        } else {
+            dst[i] = src[i];
+        }
+    }
+}
+
+turboPmacController::turboPmacController(const char *portName,
+                                         const char *ipPortConfigName,
+                                         int numAxes, double movingPollPeriod,
+                                         double idlePollPeriod,
+                                         double comTimeout, int numExtraParams)
+    : sinqController(
+          portName, ipPortConfigName, numAxes, movingPollPeriod, idlePollPeriod,
+          /*
+          The following parameter library entries are added in this driver:
+          - REREAD_ENCODER_POSITION
+          - READ_CONFIG
+          */
+          numExtraParams + NUM_turboPmac_DRIVER_PARAMS)
+
+{
+
+    // Initialization of local variables
+    asynStatus status = asynSuccess;
+
+    // Initialization of all member variables
+    comTimeout_ = comTimeout;
+
+    // Maximum allowed number of subsequent timeouts before the user is
+    // informed.
+    maxSubsequentTimeouts_ = 10;
+
+    // =========================================================================
+    // Create additional parameter library entries
+
+    status = createParam("REREAD_ENCODER_POSITION", asynParamInt32,
+                         &rereadEncoderPosition_);
+    if (status != asynSuccess) {
+        asynPrint(this->pasynUser(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\" => %s, line %d\nFATAL ERROR (creating a "
+                  "parameter failed with %s).\nTerminating IOC",
+                  portName, __PRETTY_FUNCTION__, __LINE__,
+                  stringifyAsynStatus(status));
+        exit(-1);
+    }
+
+    status = createParam("READ_CONFIG", asynParamInt32, &readConfig_);
+    if (status != asynSuccess) {
+        asynPrint(this->pasynUser(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\" => %s, line %d\nFATAL ERROR (creating a "
+                  "parameter failed with %s).\nTerminating IOC",
+                  portName, __PRETTY_FUNCTION__, __LINE__,
+                  stringifyAsynStatus(status));
+        exit(-1);
+    }
+
+    status = createParam("FLUSH_HARDWARE", asynParamInt32, &flushHardware_);
+    if (status != asynSuccess) {
+        asynPrint(this->pasynUser(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\" => %s, line %d\nFATAL ERROR (creating a "
+                  "parameter failed with %s).\nTerminating IOC",
+                  portName, __PRETTY_FUNCTION__, __LINE__,
+                  stringifyAsynStatus(status));
+        exit(-1);
+    }
+
+    /*
+    Define the end-of-string of a message coming from the device to EPICS.
+    It is not necessary to append a terminator to outgoing messages, since
+    the message length is encoded in the message header in the getSetResponse
+    method.
+    */
+    const char *message_from_device =
+        "\006"; // Hex-code for ACK (acknowledge) -> Each message from the MCU
+                // is terminated by this value
+    status = pasynOctetSyncIO->setInputEos(pasynOctetSyncIOipPort_,
+                                           message_from_device,
+                                           strlen(message_from_device));
+    if (status != asynSuccess) {
+        asynPrint(this->pasynUser(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\" => %s, line %d\nFATAL ERROR "
+                  "(setting input EOS failed with %s).\nTerminating IOC",
+                  portName, __PRETTY_FUNCTION__, __LINE__,
+                  stringifyAsynStatus(status));
+        pasynOctetSyncIO->disconnect(pasynOctetSyncIOipPort_);
+        exit(-1);
+    }
+
+    status = callParamCallbacks();
+    if (status != asynSuccess) {
+        asynPrint(this->pasynUser(), ASYN_TRACE_ERROR,
+                  "Controller \"%s\" => %s, line %d\nFATAL ERROR "
+                  "(executing ParamLib callbacks failed "
+                  "with %s).\nTerminating IOC",
+                  portName, __PRETTY_FUNCTION__, __LINE__,
+                  stringifyAsynStatus(status));
+        pasynOctetSyncIO->disconnect(pasynOctetSyncIOipPort_);
+        exit(-1);
+    }
+
+    // =========================================================================;
+
+    /*
+    We try to connect to the port via the port name provided by the constructor.
+    If this fails, the function is terminated via exit.
+    */
+    pasynInt32SyncIO->connect(ipPortConfigName, 0, &pasynInt32SyncIOipPort_,
+                              NULL);
+    if (status != asynSuccess || pasynInt32SyncIOipPort_ == nullptr) {
+        errlogPrintf("Controller \"%s\" => %s, line %d:\nFATAL ERROR (cannot "
+                     "connect to MCU controller).\n"
+                     "Terminating IOC",
+                     portName, __PRETTY_FUNCTION__, __LINE__);
+        exit(-1);
+    }
+}
+
+/*
+Access one of the axes of the controller via the axis adress stored in asynUser.
+If the axis does not exist or is not a Axis, a nullptr is returned and an
+error is emitted.
+*/
+turboPmacAxis *turboPmacController::getTurboPmacAxis(asynUser *pasynUser) {
+    asynMotorAxis *asynAxis = asynMotorController::getAxis(pasynUser);
+    return dynamic_cast<turboPmacAxis *>(asynAxis);
+}
+
+/*
+Access one of the axes of the controller via the axis index.
+If the axis does not exist or is not a Axis, the function must return Null
+*/
+turboPmacAxis *turboPmacController::getTurboPmacAxis(int axisNo) {
+    asynMotorAxis *asynAxis = asynMotorController::getAxis(axisNo);
+    return dynamic_cast<turboPmacAxis *>(asynAxis);
+}
+
+asynStatus turboPmacController::writeRead(int axisNo, const char *command,
+                                          char *response,
+                                          int numExpectedResponses) {
+
+    // Definition of local variables.
+    asynStatus status = asynSuccess;
+    asynStatus paramLibStatus = asynSuccess;
+    asynStatus timeoutStatus = asynSuccess;
+    // char fullCommand[MAXBUF_] = {0};
+    char drvMessageText[MAXBUF_] = {0};
+    char modResponse[MAXBUF_] = {0};
+    int motorStatusProblem = 0;
+    int numReceivedResponses = 0;
+
+    /*
+    asyn defines the following reasons for an end-of-message coming from the MCU
+    (https://epics.anl.gov/modules/soft/asyn/R4-14/asynDriver.pdf, p. 28):
+    0: Timeout
+    1: Request count reached
+    2: End of string detected -> In this driver, this is the "normal" case
+    4: End indicator detected
+    Combinations of reasons are also possible, e.g. eomReason = 5 would mean
+    that both the request count was reached and an end indicator was detected.
+     */
+    int eomReason = 0;
+
+    // Number of bytes of the outgoing message (which is command + the
+    // end-of-string terminator defined in the constructor)
+    size_t nbytesOut = 0;
+
+    // Number of bytes of the incoming message (which is response + the
+    // end-of-string terminator defined in the constructor)
+    size_t nbytesIn = 0;
+
+    // =========================================================================
+
+    turboPmacAxis *axis = getTurboPmacAxis(axisNo);
+    if (axis == nullptr) {
+        // We already did the error logging directly in getAxis
+        return asynError;
+    }
+    const size_t commandLength = strlen(command);
+
+    /*
+    The writeRead command performs the following steps:
+    1) Flush the socket buffer on the IOC side (not the controller!)
+    2) Write a command to the controller
+    3) Read the response
+
+    If a timeout occurs during writing or reading, inform the user that we're
+    trying to reconnect. If the problem persists, ask them to call the support
+    */
+    status = pasynOctetSyncIO->writeRead(
+        pasynOctetSyncIOipPort(), command, commandLength, response, MAXBUF_,
+        comTimeout_, &nbytesOut, &nbytesIn, &eomReason);
+
+    msgPrintControlKey comKey =
+        msgPrintControlKey(portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
+
+    if (status == asynTimeout) {
+
+        if (msgPrintControl_.shouldBePrinted(comKey, true, pasynUser())) {
+            asynPrint(
+                this->pasynUser(), ASYN_TRACE_ERROR,
+                "Controller \"%s\", axis %d => %s, line %d\nTimeout while "
+                "writing to the controller. Retrying ...%s\n",
+                portName, axisNo, __PRETTY_FUNCTION__, __LINE__,
+                msgPrintControl_.getSuffix());
+        }
+
+        timeoutStatus = checkComTimeoutWatchdog(axisNo, drvMessageText,
+                                                sizeof(drvMessageText));
+
+        int timeoutCounter = 0;
+        while (1) {
+            checkMaxSubsequentTimeouts(timeoutCounter, axis);
+            timeoutCounter += 1;
+
+            if (maxSubsequentTimeoutsExceeded_) {
+                break;
+            }
+
+            status = pasynOctetSyncIO->writeRead(
+                pasynOctetSyncIOipPort(), command, commandLength, response,
+                MAXBUF_, comTimeout_, &nbytesOut, &nbytesIn, &eomReason);
+            if (status != asynTimeout) {
+                asynPrint(this->pasynUser(), ASYN_TRACE_ERROR,
+                          "Controller \"%s\", axis %d  => %s, line "
+                          "%d\nReconnected after write timeout\n",
+                          portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
+                break;
+            }
+        }
+    } else if (status != asynSuccess) {
+        if (msgPrintControl_.shouldBePrinted(comKey, true, pasynUser())) {
+            asynPrint(
+                this->pasynUser(), ASYN_TRACE_ERROR,
+                "Controller \"%s\", axis %d => %s, line %d\nError %s while "
+                "writing to the controller.%s\n",
+                portName, axisNo, __PRETTY_FUNCTION__, __LINE__,
+                stringifyAsynStatus(status), msgPrintControl_.getSuffix());
+        }
+    } else {
+        msgPrintControl_.resetCount(comKey, pasynUser());
+    }
+
+    if (timeoutStatus == asynError) {
+        status = asynError;
+    }
+
+    // The message should only ever terminate due to reason 2
+    msgPrintControlKey terminateKey =
+        msgPrintControlKey(portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
+    if (eomReason != 2) {
+        status = asynError;
+
+        char reasonStringified[30] = {0};
+        switch (eomReason) {
+        case 0:
+            snprintf(reasonStringified, sizeof(reasonStringified), "Timeout");
+            break;
+        case 1:
+            snprintf(reasonStringified, sizeof(reasonStringified),
+                     "Request count reached");
+            break;
+        case 2:
+            snprintf(reasonStringified, sizeof(reasonStringified),
+                     "End of string detected");
+            break;
+        case 3:
+            snprintf(reasonStringified, sizeof(reasonStringified),
+                     "End indicator detected");
+            break;
+        }
+
+        snprintf(drvMessageText, sizeof(drvMessageText),
+                 "Terminated message due to reason %s (should be \"End of "
+                 "string detected\"). Please call the support.",
+                 reasonStringified);
+
+        if (msgPrintControl_.shouldBePrinted(terminateKey, true, pasynUser())) {
+
+            asynPrint(this->pasynUser(), ASYN_TRACE_ERROR,
+                      "Controller \"%s\", axis %d => %s, line %d\nMessage "
+                      "terminated due to reason %s.%s\n",
+                      portName, axisNo, __PRETTY_FUNCTION__, __LINE__,
+                      reasonStringified, msgPrintControl_.getSuffix());
+        }
+    } else {
+        msgPrintControl_.resetCount(terminateKey, pasynUser());
+    }
+
+    /*
+    Calculate the number of received responses by counting the number of
+    carriage returns "\r" in the response.
+    */
+    for (size_t i = 0; i < strlen(response); i++) {
+        if (response[i] == '\r') {
+            numReceivedResponses++;
+        }
+    }
+    msgPrintControlKey numResponsesKey =
+        msgPrintControlKey(portName, axisNo, __PRETTY_FUNCTION__, __LINE__);
+    if (numExpectedResponses != numReceivedResponses) {
+        adjustResponseForPrint(modResponse, response, MAXBUF_);
+
+        if (msgPrintControl_.shouldBePrinted(numResponsesKey, true,
+                                             pasynUser())) {
+            asynPrint(
+                this->pasynUser(), ASYN_TRACE_ERROR,
+                "Controller \"%s\", axis %d => %s, line %d\nUnexpected "
+                "response '%s' (carriage returns are replaced with spaces) "
+                "for command %s.%s\n",
+                portName, axisNo, __PRETTY_FUNCTION__, __LINE__, modResponse,
+                command, msgPrintControl_.getSuffix());
+        }
+
+        snprintf(drvMessageText, sizeof(drvMessageText),
+                 "Received unexpected response '%s' (carriage returns "
+                 "are replaced with spaces) for command %s. "
+                 "Please call the support",
+                 modResponse, command);
+        status = asynError;
+    } else {
+        msgPrintControl_.resetCount(numResponsesKey, pasynUser());
+    }
+
+    // Create custom error messages for different failure modes, if no error
+    // message has been set yet
+    if (strlen(drvMessageText) == 0) {
+        switch (status) {
+        case asynSuccess:
+            break; // Communicate nothing
+        case asynTimeout:
+            snprintf(drvMessageText, sizeof(drvMessageText),
+                     "connection timeout for axis %d", axisNo);
+            break;
+        case asynDisconnected:
+            snprintf(drvMessageText, sizeof(drvMessageText),
+                     "axis is not connected");
+            break;
+        case asynDisabled:
+            snprintf(drvMessageText, sizeof(drvMessageText),
+                     "axis is disabled");
+            break;
+        default:
+            snprintf(drvMessageText, sizeof(drvMessageText),
+                     "Communication failed (%s)", stringifyAsynStatus(status));
+            break;
+        }
+    }
+
+    // Log the overall status (communication successfull or not)
+    if (status == asynSuccess) {
+        paramLibStatus = axis->setIntegerParam(this->motorStatusCommsError_, 0);
+    } else {
+        // Check if the axis already is in an error communication mode. If
+        // it is not, upstream the error. This is done to avoid "flooding"
+        // the user with different error messages if more than one error
+        // ocurred before an error-free communication
+        paramLibStatus =
+            getIntegerParam(axisNo, motorStatusProblem_, &motorStatusProblem);
+        if (paramLibStatus != asynSuccess) {
+            return paramLibAccessFailed(paramLibStatus, "motorStatusProblem_",
+                                        axisNo, __PRETTY_FUNCTION__, __LINE__);
+        }
+
+        if (motorStatusProblem == 0) {
+            paramLibStatus =
+                axis->setStringParam(motorMessageText_, drvMessageText);
+            if (paramLibStatus != asynSuccess) {
+                return paramLibAccessFailed(paramLibStatus, "motorMessageText_",
+                                            axisNo, __PRETTY_FUNCTION__,
+                                            __LINE__);
+            }
+
+            paramLibStatus = axis->setIntegerParam(motorStatusProblem_, 1);
+            if (paramLibStatus != asynSuccess) {
+                return paramLibAccessFailed(paramLibStatus,
+                                            "motorStatusProblem", axisNo,
+                                            __PRETTY_FUNCTION__, __LINE__);
+            }
+
+            paramLibStatus = axis->setIntegerParam(motorStatusProblem_, 1);
+            if (paramLibStatus != asynSuccess) {
+                return paramLibAccessFailed(paramLibStatus,
+                                            "motorStatusCommsError_", axisNo,
+                                            __PRETTY_FUNCTION__, __LINE__);
+            }
+        }
+    }
+    return status;
+}
+
+asynStatus turboPmacController::doFlushHardware() {
+    /*
+    Temporarily overwrite the "reason" field with the FLUSH_HARDWARE
+    constant defined in pmacAsynIPPort.c. This reason is then used within
+    the write method of pasynInt32SyncIO to select the flush function.
+    */
+    int temp = pasynInt32SyncIOipPort_->reason;
+    pasynInt32SyncIOipPort_->reason = FLUSH_HARDWARE;
+    asynStatus status = (asynStatus)pasynInt32SyncIO->write(
+        pasynInt32SyncIOipPort_, 1, comTimeout_);
+
+    // Reset the status afterwards
+    pasynInt32SyncIOipPort_->reason = temp;
+    return status;
+}
+
+asynStatus turboPmacController::writeInt32(asynUser *pasynUser,
+                                           epicsInt32 value) {
+    int function = pasynUser->reason;
+
+    // =====================================================================
+
+    turboPmacAxis *axis = getTurboPmacAxis(pasynUser);
+
+    // Handle custom PVs
+    if (function == rereadEncoderPosition_) {
+        return axis->rereadEncoder();
+    } else if (function == readConfig_) {
+        return axis->init();
+    } else if (function == flushHardware_) {
+        return doFlushHardware();
+    } else {
+        return sinqController::writeInt32(pasynUser, value);
+    }
+}
+
+asynStatus turboPmacController::couldNotParseResponse(const char *command,
+                                                      const char *response,
+                                                      int axisNo,
+                                                      const char *functionName,
+                                                      int lineNumber) {
+    char modifiedResponse[MAXBUF_] = {0};
+    adjustResponseForPrint(modifiedResponse, response, MAXBUF_);
+    return sinqController::couldNotParseResponse(
+        command, modifiedResponse, axisNo, functionName, lineNumber);
+}
+
+/*************************************************************************************/
+/** The following functions are C-wrappers, and can be called directly from
+ * iocsh */
+
+extern "C" {
+
+/*
+C wrapper for the controller constructor. Please refer to the
+turboPmacController constructor documentation.
+*/
+asynStatus turboPmacCreateController(const char *portName,
+                                     const char *ipPortConfigName, int numAxes,
+                                     double movingPollPeriod,
+                                     double idlePollPeriod, double comTimeout) {
+    /*
+    We create a new instance of the controller, using the "new" keyword to
+    allocate it on the heap while avoiding RAII.
+    https://github.com/epics-modules/motor/blob/master/motorApp/MotorSrc/asynMotorController.cpp
+    https://github.com/epics-modules/asyn/blob/master/asyn/asynPortDriver/asynPortDriver.cpp
+
+    The created object is registered in EPICS in its constructor and can
+    safely be "leaked" here.
+    */
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+    turboPmacController *pController =
+        new turboPmacController(portName, ipPortConfigName, numAxes,
+                                movingPollPeriod, idlePollPeriod, comTimeout);
+
+    return asynSuccess;
+}
+
+/*
+Define name and type of the arguments for the CreateController function
+in the iocsh. This is done by creating structs with the argument names and
+types and then providing "factory" functions
+(configCreateControllerCallFunc). These factory functions are used to
+register the constructors during compilation.
+*/
+static const iocshArg CreateControllerArg0 = {"Controller name (e.g. mcu1)",
+                                              iocshArgString};
+static const iocshArg CreateControllerArg1 = {"Asyn IP port name (e.g. pmcu1)",
+                                              iocshArgString};
+static const iocshArg CreateControllerArg2 = {"Number of axes", iocshArgInt};
+static const iocshArg CreateControllerArg3 = {"Moving poll rate (s)",
+                                              iocshArgDouble};
+static const iocshArg CreateControllerArg4 = {"Idle poll rate (s)",
+                                              iocshArgDouble};
+static const iocshArg CreateControllerArg5 = {"Communication timeout (s)",
+                                              iocshArgDouble};
+static const iocshArg *const CreateControllerArgs[] = {
+    &CreateControllerArg0, &CreateControllerArg1, &CreateControllerArg2,
+    &CreateControllerArg3, &CreateControllerArg4, &CreateControllerArg5};
+static const iocshFuncDef configTurboPmacCreateController = {
+    "turboPmacController", 6, CreateControllerArgs};
+static void configTurboPmacCreateControllerCallFunc(const iocshArgBuf *args) {
+    turboPmacCreateController(args[0].sval, args[1].sval, args[2].ival,
+                              args[3].dval, args[4].dval, args[5].dval);
+}
+
+// This function is made known to EPICS in turboPmac.dbd and is called by
+// EPICS in order to register both functions in the IOC shell
+static void turboPmacControllerRegister(void) {
+    iocshRegister(&configTurboPmacCreateController,
+                  configTurboPmacCreateControllerCallFunc);
+}
+epicsExportRegistrar(turboPmacControllerRegister);
+
+} // extern "C"

src/turboPmacController.h

@@ -1,22 +1,22 @@
 /********************************************
- *  pmacv3Controller.h
+ *  turboPmacController.h
  *
- * PMAC V3 controller driver based on the asynMotorController class
+ * Turbo PMAC controller driver based on the asynMotorController class
  *
  * Stefan Mathis, September 2024
  ********************************************/
 
-#ifndef pmacv3Controller_H
-#define pmacv3Controller_H
-#include "pmacv3Axis.h"
+#ifndef turboPmacController_H
+#define turboPmacController_H
 #include "sinqAxis.h"
 #include "sinqController.h"
+#include "turboPmacAxis.h"
 
-class pmacv3Controller : public sinqController {
-
+class turboPmacController : public sinqController {
   public:
     /**
-     * @brief Construct a new pmacv3Controller object
+     * @brief Construct a new turboPmacController object. This function is meant
+    to be called from a child class constructor.
      *
      * @param portName            See sinqController constructor
      * @param ipPortConfigName    See sinqController constructor
@@ -26,26 +26,30 @@ class pmacv3Controller : public sinqController {
      * @param comTimeout          When trying to communicate with the device,
     the underlying asynOctetSyncIO interface waits for a response until this
     time (in seconds) has passed, then it declares a timeout.
+     * @param numExtraParams      Number of extra parameters from a child class
      */
-    pmacv3Controller(const char *portName, const char *ipPortConfigName,
-                     int numAxes, double movingPollPeriod,
-                     double idlePollPeriod, double comTimeout);
+    turboPmacController(const char *portName, const char *ipPortConfigName,
+                        int numAxes, double movingPollPeriod,
+                        double idlePollPeriod, double comTimeout,
+                        int numExtraParams = 0);
 
     /**
      * @brief Get the axis object
      *
      * @param pasynUser           Specify the axis via the asynUser
-     * @return pmacv3Axis*        If no axis could be found, this is a nullptr
+     * @return turboPmacAxis*        If no axis could be found, this is a
+     * nullptr
      */
-    pmacv3Axis *getAxis(asynUser *pasynUser);
+    turboPmacAxis *getTurboPmacAxis(asynUser *pasynUser);
 
     /**
      * @brief Get the axis object
      *
      * @param axisNo              Specify the axis via its index
-     * @return pmacv3Axis*        If no axis could be found, this is a nullptr
+     * @return turboPmacAxis*        If no axis could be found, this is a
+     * nullptr
      */
-    pmacv3Axis *getAxis(int axisNo);
+    turboPmacAxis *getTurboPmacAxis(int axisNo);
 
     /**
      * @brief Overloaded function of sinqController
@@ -56,10 +60,7 @@ class pmacv3Controller : public sinqController {
      * @param value               New value
      * @return asynStatus
      */
-    asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value);
-
-  protected:
-    asynUser *lowLevelPortUser_;
+    virtual asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value);
 
     /**
      * @brief Send a command to the hardware and receive a response
@@ -81,22 +82,13 @@ class pmacv3Controller : public sinqController {
                          int numExpectedResponses);
 
     /**
-     * @brief Save cast of the given asynAxis pointer to a pmacv3Axis pointer.
-     * If the cast fails, this function returns a nullptr.
-     *
-     * @param asynAxis
-     * @return pmacv3Axis*
-     */
-    pmacv3Axis *castToAxis(asynMotorAxis *asynAxis);
-
-    /**
-     * @brief Specialized version of sinqController::errMsgCouldNotParseResponse
-     * for pmacv3
+     * @brief Specialized version of sinqController::couldNotParseResponse
+     * for turboPmac
      *
      * This is an overloaded version of
-     * sinqController::errMsgCouldNotParseResponse which calls
+     * sinqController::couldNotParseResponse which calls
      * adjustResponseForLogging on response before handing it over to
-     * sinqController::errMsgCouldNotParseResponse.
+     * sinqController::couldNotParseResponse.
      *
      * @param command             Command which led to the unparseable message
      * @param response            Response which wasn't parseable
@@ -107,30 +99,53 @@ class pmacv3Controller : public sinqController {
     called. It is recommended to use a macro, e.g. __LINE__.
      * @return asynStatus         Returns asynError.
      */
-    asynStatus errMsgCouldNotParseResponse(const char *command,
-                                           const char *response, int axisNo_,
-                                           const char *functionName,
-                                           int lineNumber);
+    asynStatus couldNotParseResponse(const char *command, const char *response,
+                                     int axisNo_, const char *functionName,
+                                     int lineNumber);
+
+    /**
+     * @brief Perform a hardware flush (clearing of communication buffers)
+     *
+     * The PMAC controllers hardware buffers can be flushed (see Turbo PMAC user
+     * manual, p. 414). This "freezes" the PMAC for around 10 ms and should
+     * therefore only be done if it is necessary (i.e. not as part of the
+     * regular communication procedure).
+     *
+     * @return asynStatus
+     */
+    asynStatus doFlushHardware();
+
+    // Accessors for additional PVs
+    int rereadEncoderPosition() { return rereadEncoderPosition_; }
+    int readConfig() { return readConfig_; }
+    int flushHardware() { return flushHardware_; }
 
-  private:
     // Set the maximum buffer size. This is an empirical value which must be
     // large enough to avoid overflows for all commands to the device /
     // responses from it.
     static const uint32_t MAXBUF_ = 200;
 
+    asynUser *pasynInt32SyncIOipPort() { return pasynInt32SyncIOipPort_; }
+
+  protected:
     /*
-    Stores the constructor input comTimeout
+    Timeout for the communication process in seconds
     */
     double comTimeout_;
 
+    char lastResponse[MAXBUF_];
+
+    // User for writing int32 values to the port driver.
+    asynUser *pasynInt32SyncIOipPort_;
+
     // Indices of additional PVs
-#define FIRST_PMACV3_PARAM rereadEncoderPosition_
+#define FIRST_turboPmac_PARAM rereadEncoderPosition_
     int rereadEncoderPosition_;
     int readConfig_;
-#define LAST_PMACV3_PARAM readConfig_
-
-    friend class pmacv3Axis;
+    int flushHardware_;
+#define LAST_turboPmac_PARAM flushHardware_
 };
-#define NUM_PMACV3_DRIVER_PARAMS (&LAST_PMACV3_PARAM - &FIRST_PMACV3_PARAM + 1)
+#define NUM_turboPmac_DRIVER_PARAMS                                            \
+    (&LAST_turboPmac_PARAM - &FIRST_turboPmac_PARAM + 1)
 
-#endif /* pmacv3Controller_H */
+#endif /* turboPmacController_H */

utils/analyzeTcpDump/analyzeTcpDump.py

@@ -0,0 +1,201 @@
+#! venv/bin/python3
+"""
+This script can be used to format the communication between an EPICS IOC and a
+PMAC MCU into JSON files. It does this by parsing PCAP files created by tcpdump
+and rearranging the information in a more structured manner.
+
+To read the manual, simply run this script without any arguments.
+
+Stefan Mathis, January 2025
+"""
+
+from scapy.all import *
+import json
+import re
+import codecs
+import os
+from datetime import datetime
+
+def parse(fileAndPath):
+
+    try:
+        scapyCap = PcapReader(fileAndPath)
+    except:
+        print(f"Could not read file {fileAndPath} as PCAP file")
+
+    requests = []
+    sent = []
+
+    jsonDict = dict()
+    lastLayer = None
+    for packet in scapyCap:
+
+        layer = packet.getlayer(Raw)
+
+        if layer is None:
+            continue
+
+        # Skip the package if it is not a command or a response. A command ends 
+        # with a carriage return (x0d), a response ends with ACKNOWLEDGE (x06)
+        last = layer.load[-1]
+        if last == 6:
+            isResponse = True
+        elif last == 13:
+            isResponse = False
+        else:
+            continue
+
+        # Store the info by the IP adress of the MCU
+        if isResponse:
+            ip = packet[IP].src
+        else:
+            ip = packet[IP].dst
+
+        if ip not in jsonDict:
+            jsonDict[ip] = dict()
+
+        # Convert to ASCII
+        ascii = layer.load.decode("unicode_escape")
+
+        # Convert the time to a float
+        time = float(packet.time)
+
+        if isResponse:
+
+            # A response is always a number followed by a carriage return
+            responses = re.findall("-?\d+\.\d+\r|-?\d+\r", ascii)
+
+            # Check if the number of responses matches the number of requests
+            valid = len(responses) == len(requests)
+
+            # Pair up the request-response pairs
+            for (request, response) in zip(requests, responses):
+                if request not in jsonDict[ip]:
+                    jsonDict[ip][request] = dict()
+
+                if "." in response:
+                    value = float(response)
+                else:
+                    value = int(response)
+                
+                lastLayer = lastPacket.getlayer(Raw)
+                lastTime = float(lastPacket.time)
+                data = {
+                    'command': {
+                        'hex': [format(value, '02x') for value in lastLayer.load],
+                        'ascii': lastLayer.load.decode("unicode_escape"),
+                        'timestamp': lastTime,
+                        'timeiso': str(datetime.fromtimestamp(lastTime).isoformat()),
+                    },
+                    'response': {
+                        'hex': [format(value, '02x') for value in layer.load],
+                        'ascii': ascii,
+                        'value': value,
+                        'timestamp': time,
+                        'timeiso': str(datetime.fromtimestamp(time).isoformat()),
+                        'valid': valid
+                    }
+                }
+                jsonDict[ip][request][time] = data
+        else:
+            requests.clear()
+            sent.clear()
+            
+            # Store the packet for use in the response iteration
+            lastPacket = packet
+
+            # Parse the ASCII text via regex. A PMAC command usually has the 
+            # format LDDDD(=<Number>), where L is a capital letter, the first 
+            # two digits D are the axis number and the last two digits together
+            # with the letter form the command.
+
+            # Separate the commands into sent data (e.g. setting a position)
+            # and data requests (e.g. reading the axis status). Sent data always
+            # has an equal sign.
+            for command in re.findall("[A-Z]\d+=-?\d+|[A-Z]\d+", ascii):
+                if "=" in command:
+                    sent.append(command)
+                else:
+                    requests.append(command)
+                       
+            # Store the sent. The requests yfd stored together with the responses later.
+            for command in sent:
+                splitted = command.split("=")
+                key = splitted[0]
+                key = key + "="
+                if key not in jsonDict[ip]:
+                    jsonDict[ip][key] = dict()
+                
+                if "." in splitted[1]:
+                    value = float(splitted[1])
+                else:
+                    value = int(splitted[1])
+
+                data = {
+                    'command': {
+                        'hex': [format(value, '02x') for value in layer.load],
+                        'ascii': ascii,
+                        'value': value,
+                        'timestamp': time,
+                        'timeiso': str(datetime.fromtimestamp(time).isoformat()),
+                    },
+                }
+
+                jsonDict[ip][key][time] = data
+
+    return jsonDict
+
+
+if __name__ == "__main__":
+
+    isInstalled = False
+    try: 
+        from scapy.all import *
+        isInstalled = True
+
+    except ImportError:
+        print("This script needs the Scapy package to run. In order to install a "
+            "suitable virtual environment, use the 'makevenv' script.")
+    
+    if isInstalled:
+        from sys import argv
+
+        if len(argv) < 2:
+            print("""
+This script can be used to format the communication between an EPICS IOC and a
+PMAC MCU into JSON files. It does this by parsing PCAP files created by tcpdump
+and rearranging the information in a more structured manner.
+
+After a successfull parse run, the resulting JSON data looks like this:
+<IP Adress MCU1>
+    <Request command type> (e.g. Q0100 to request the position of axis 1)
+        <Event timestamp>
+            Command
+                <Raw ASCII string>
+                <Actual command> (e.g. P0100)
+                <Timestamp in Epoch>
+            Response
+                <Raw ASCII string>
+                <Actual response (e.g. -3)
+                <Timestamp in Epoch>
+    <Set command type> (e.g. Q0100= to set the position of axis 1)
+        <Event timestamp>
+            Command
+                <Raw ASCII string>
+                <Actual command (e.g. P0100)
+                <Set value>
+                <Timestamp in Epoch>
+<IP Adress MCU2>
+            """)
+
+        else:
+            for fileAndPath in argv[1:]:
+                jsonDict = parse(fileAndPath)
+
+                # Save the dict into a JSON
+                fileName = os.path.basename(fileAndPath)
+                jsonfileAndPath = f"{fileName}.json"
+                with open(jsonfileAndPath, 'w') as fp:
+                    json.dump(jsonDict, fp, indent=4)
+
+                print(f"Stored parse result of {fileAndPath} in {fileName}")

utils/analyzeTcpDump/demo.py

@@ -0,0 +1,83 @@
+#! demovenv/bin/python3
+"""
+This demo script shows how the "parse" function of "analyzeTcpDump.py" can be 
+used to easily visualize data from a PCAP file created by the tcpdump tool / 
+wireshark. A suitable virtual environment can be created with the "makedemovenv"
+script.
+
+Stefan Mathis, January 2025
+"""
+
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+from datetime import datetime, timedelta
+
+from analyzeTcpDump import parse
+
+if __name__ == "__main__":
+
+    data = parse("demo.pcap")
+
+    plt.figure(figsize=(12, 6)) 
+
+    # Plot the position of axis 5 over time
+
+    # Actual position
+    position_valid = []
+    dates_valid = []
+    position_all = []
+    dates_all = []
+
+    for (timestamp, item) in data["172.28.101.24"]["Q0510"].items():
+        date = datetime.fromtimestamp(timestamp) 
+        value = item["response"]["value"]
+
+        dates_all.append(date)
+        position_all.append(value)
+
+        if item["response"]["valid"]:
+            dates_valid.append(date)
+            position_valid.append(value)
+        else:
+            command = item["command"]["ascii"]
+            response = item["response"]["ascii"]
+
+            # Replace non-renderable characters
+            command = command.replace("\0", "\\x00")
+            command = command.replace("\r", "\\x0d")
+            command = command.replace("\x12", "\\x12")
+            response = response.replace("\r", "\\x0d")
+            response = response.replace("\06", "\\x06")
+
+            # Shift the text a bit to the right
+            plt.text(date, value, f"Command: {command}\nResponse: {response}", horizontalalignment="right", verticalalignment="top")
+
+    # Target position
+    position_target = [position_valid[0]]
+    dates_target = [dates_valid[0]]
+
+    for (timestamp, item) in data["172.28.101.24"]["Q0501="].items():
+        date = datetime.fromtimestamp(timestamp) 
+        value = item["command"]["value"]
+
+        dates_target.append(date)
+        position_target.append(position_target[-1])
+
+        dates_target.append(date)
+        position_target.append(value)
+
+    dates_target.append(dates_valid[-1])
+    position_target.append(position_target[-1])
+
+    plt.plot(dates_target, position_target, "k--", label="Target position")
+    plt.plot(dates_all, position_all, "r-", label="All responses")
+    plt.plot(dates_valid, position_valid, "b-", label="Valid responses")
+    plt.xlabel("Time (ISO 8601)")
+    plt.ylabel("Axis position in degree")
+    plt.gca().xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%dT%H:%M:%S"))
+    plt.xticks(rotation=45)
+    plt.grid(True)
+    plt.legend(loc="lower left")
+    plt.title("Position of axis 5")
+    plt.tight_layout()
+    plt.show()

utils/analyzeTcpDump/makedemovenv

@@ -0,0 +1,22 @@
+#!/bin/bash
+#-------------------------------------------------------------------------
+# Script which installs a virtual environment for PCAP file parsing
+#
+# Stefan Mathis, September 2024
+#-------------------------------------------------------------------------
+
+# Remove any previous testing environment
+if [ -d "demovenv" ]; then
+    rm -r demovenv
+fi
+
+/usr/bin/python3.11 -m venv demovenv
+
+source demovenv/bin/activate
+
+pip install --upgrade pip
+pip install "scapy>=2.5,<3.0"
+pip install matplotlib
+
+# Exit the virtual environment
+exit

utils/analyzeTcpDump/makevenv

@@ -0,0 +1,21 @@
+#!/bin/bash
+#-------------------------------------------------------------------------
+# Script which installs a virtual environment for PCAP file parsing
+#
+# Stefan Mathis, September 2024
+#-------------------------------------------------------------------------
+
+# Remove any previous testing environment
+if [ -d "venv" ]; then
+    rm -r venv
+fi
+
+/usr/bin/python3.11 -m venv venv
+
+source venv/bin/activate
+
+pip install --upgrade pip
+pip install "scapy>=2.5,<3.0"
+
+# Exit the virtual environment
+exit

utils/writeRead.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+This script allows direct interaction with a pmac-Controller over an ethernet connection.
+To read the manual, simply run this script without any arguments.
+
+Stefan Mathis, December 2024
+"""
+
+import struct
+import socket
+import curses
+
+def packPmacCommand(command):
+    # 0x40 = VR_DOWNLOAD 
+    # 0xBF = VR_PMAC_GETRESPONSE
+    buf = struct.pack('BBHHH',0x40,0xBF,0,0,socket.htons(len(command)))
+    buf = buf + bytes(command,'utf-8')
+    return buf
+
+def readPmacReply(input):
+    msg = bytearray()
+    expectAck = True
+    while True:
+        b = input.recv(1)
+        bint = int.from_bytes(b,byteorder='little')
+        if bint == 2 or bint == 7: #STX or BELL
+            expectAck = False
+            continue
+        if expectAck and bint == 6: # ACK
+            return bytes(msg)
+        else:
+            if bint == 13 and not expectAck: # CR
+                return bytes(msg)
+            else:
+                msg.append(bint)
+
+if __name__ == "__main__":
+    from sys import argv
+
+    try:
+
+        addr = argv[1].split(':')
+        s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
+        s.connect((addr[0],int(addr[1])))
+
+        if len(argv) == 3:
+            buf = packPmacCommand(argv[2])
+            s.send(buf)
+            reply = readPmacReply(s)
+            print(reply.decode('utf-8') + '\n')
+
+        else:
+
+            try:
+
+                stdscr = curses.initscr()
+                curses.noecho()
+                curses.cbreak()
+                stdscr.keypad(True)
+                stdscr.scrollok(True)
+
+                stdscr.addstr(">> ")
+                stdscr.refresh()
+
+                history = [""]
+                ptr = len(history) - 1
+
+                while True:
+                    c = stdscr.getch()
+                    if c == curses.KEY_RIGHT:
+                        (y, x) = stdscr.getyx()
+                        if x < len(history[ptr]) + 3:
+                            stdscr.move(y, x+1)
+                            stdscr.refresh()
+                    elif c == curses.KEY_LEFT:
+                        (y, x) = stdscr.getyx()
+                        if x > 3:
+                            stdscr.move(y, x-1)
+                            stdscr.refresh()
+                    elif c == curses.KEY_UP:
+                        if ptr > 0:
+                            ptr -= 1
+                            stdscr.addch("\r")
+                            stdscr.clrtoeol() 
+                            stdscr.addstr(">> " + history[ptr])
+                    elif c == curses.KEY_DOWN:
+                        if ptr < len(history) - 1:
+                            ptr += 1
+                            stdscr.addch("\r")
+                            stdscr.clrtoeol() 
+                            stdscr.addstr(">> " + history[ptr])
+                    elif c == curses.KEY_ENTER or c == ord('\n') or c == ord('\r'):
+                        if history[ptr] == 'quit':
+                            break
+
+                        # because of arrow keys move back to the end of the line
+                        (y, x) = stdscr.getyx()
+                        stdscr.move(y, 3+len(history[ptr]))
+
+                        if history[ptr]:
+                            buf = packPmacCommand(history[ptr])
+                            s.send(buf)
+                            reply = readPmacReply(s)
+                            stdscr.addstr("\n" + reply.decode('utf-8')[0:-1])
+
+                        if ptr == len(history) - 1 and history[ptr] != "":
+                            history += [""]
+                        else:
+                            history[-1] = ""
+                        ptr = len(history) - 1
+
+                        stdscr.addstr("\n>> ")
+                        stdscr.refresh()
+
+                    else:
+                        if ptr < len(history) - 1: # Modifying previous input
+                            if len(history[-1]) == 0:
+                                history[-1] = history[ptr]
+                                ptr = len(history) - 1
+
+                            else:
+                                history += [history[ptr]]
+                                ptr = len(history) - 1
+
+                        if c == curses.KEY_BACKSPACE:
+                            if len(history[ptr]) == 0:
+                                continue
+                            (y, x) = stdscr.getyx()
+                            history[ptr] = history[ptr][0:x-4] + history[ptr][x-3:]
+                            stdscr.addch("\r")
+                            stdscr.clrtoeol() 
+                            stdscr.addstr(">> " + history[ptr])
+                            stdscr.move(y, x-1)
+                            stdscr.refresh()
+
+                        else:
+                            (y, x) = stdscr.getyx()
+                            history[ptr] = history[ptr][0:x-3] + chr(c) + history[ptr][x-3:]
+                            stdscr.addch("\r")
+                            stdscr.clrtoeol() 
+                            stdscr.addstr(">> " + history[ptr])
+                            stdscr.move(y, x+1)
+                            stdscr.refresh()
+
+            finally:
+
+                # to quit
+                curses.nocbreak()
+                stdscr.keypad(False)
+                curses.echo()
+                curses.endwin()
+
+    except:
+        print("""
+        Invalid Arguments
+
+        Option 1: Single Command
+        ------------------------
+
+        Usage: writeRead.py pmachost:port command
+        This then returns the response for command. 
+
+        Option 2: CLI Mode
+        ------------------
+
+        Usage: writeRead.py pmachost:port
+
+        You can then type in a command, hit enter, and the response will see
+        the reponse, before being prompted to again enter a command. Type
+        'quit' to close prompt.
+        """)
+