EPICS asyn模块asynDriver测试实例

以下是一个示例程序，它实现了asynCommon, asynOctet和asynInt32接口，并且测试了asynDriver模块中pasynManager的核心功能函数的用法：createAsynUser, registerPort,  registerInterface，findInterface, queueRequest等

asynManager的详细介绍见：asynManager介绍

#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#include "cantProceed.h"
#include "epicsStdio.h"
#include "epicsThread.h"
#include "iocsh.h"

#include "asynDriver.h"
#include "asynOctet.h"
#include "asynInt32.h"

#include <epicsExport.h>
#define BUFFERSIZE 4096

static int VALUE = 0;

typedef struct deviceBuffer{
        char    buffer[BUFFERSIZE];
        size_t  nchars;
        int     value;
        int     low;
        int     high;
}deviceBuffer;

typedef struct deviceInfo{
        deviceBuffer    buffer;
        int             connected;
}deviceInfo;

typedef struct infoPvt{
        deviceInfo      device;
        const char      * portName;
        int             connected;
        double          delay;
        asynInterface   common;
        asynInterface   octet;
        asynInterface   int32;
        char            eos[2];
        int             eoslen;
        void            * pasynPvt;
        void            * pasynInt32Pvt;
}infoPvt;

static int infoDriverInit(const char * portName, double delay, int noAutoConnect, int low, int high);


/* asynCommon  */
static void report(void *drvPvt, FILE * fp, int details);
static asynStatus connect(void * drvPvt, asynUser *pasynUser);
static asynStatus disconnect(void *drvPvt, asynUser * pasynUser);
static asynCommon asynC = {report, connect, disconnect};

/* asynOctet */
static asynStatus infoWrite(void *drvPvt, asynUser *pasynUser,
                const char *data, size_t numchars, size_t *nbytesTransfered);
static asynStatus infoRead(void *drvPvt, asynUser *pasynUser,
                char *data, size_t maxchars, size_t *nbytesTransfered, int *eomReason);
static asynStatus infoFlush(void *drvPvt, asynUser *pasynUser);
static asynStatus setEos(void *drvPvt, asynUser *pasynUser, const char *eos, int eoslen);
static asynStatus getEos(void *drvPvt, asynUser *pasynUser, char *eos, int eossize, int *eoslen);
static asynOctet asynO;

/* asynInt32*/
static asynStatus intWrite(void *drvPvt, asynUser * pasynUser, epicsInt32 value);
static asynStatus intRead(void *drvPvt, asynUser * pasynUser, epicsInt32 *value);
static asynStatus getIntBounds(void *drvPvt, asynUser * pasynUser, epicsInt32 *low, epicsInt32 *high);
static asynInt32 asynI32;


static int infoDriverInit(const char * pn, double delay, int noAutoConnect, int low, int high)
{
        infoPvt         *pinfoPvt;
        char            *portName;
        asynStatus      status;
        size_t          nbytes;
        int             attributes;

        nbytes = sizeof(infoPvt) + strlen(pn) + 1;
        pinfoPvt = (infoPvt *)callocMustSucceed(nbytes, sizeof(char), "infoPvt");
        portName = (char *)(pinfoPvt + 1);
        strcpy(portName, pn);

        pinfoPvt->device.buffer.low = low;
        pinfoPvt->device.buffer.high = high;
        pinfoPvt->device.buffer.value = (low + high) / 2;

        pinfoPvt->portName = portName;
        pinfoPvt->delay = delay;
        pinfoPvt->common.interfaceType = asynCommonType;
        pinfoPvt->common.pinterface = (void *)&asynC;
        pinfoPvt->common.drvPvt = pinfoPvt;

        attributes = 0;
        if (delay > 0.0){
                attributes |= ASYN_CANBLOCK;
        }

        status = pasynManager->registerPort(portName, attributes, !noAutoConnect, 0, 0);

        if (status != asynSuccess){
                printf("infoDriverInit registerDriver failed\n");
                return 0;
        }

        status = pasynManager->registerInterface(portName, &pinfoPvt->common);
        if (status != asynSuccess){
                printf("infoDriverInit registerInterface failed");
                return 0;
        }


        asynO.write = infoWrite;
        asynO.read = infoRead;
        asynO.flush = infoFlush;
        asynO.setInputEos = setEos;
        asynO.getInputEos = getEos;
        pinfoPvt->octet.interfaceType = asynOctetType;
        pinfoPvt->octet.pinterface = (void *)&asynO;
        pinfoPvt->octet.drvPvt = pinfoPvt;

        status = pasynOctetBase->initialize(portName, &pinfoPvt->octet, 1, 1, 0);

        if (status == asynSuccess){
                status = pasynManager->registerInterruptSource(
                                portName, &pinfoPvt->octet, &pinfoPvt->pasynPvt);
        }

        if (status != asynSuccess){
                printf("infoDriverInit registerInterface asynOctet failed\n");
                return 0;
        }


        asynI32.write = intWrite;
        asynI32.read  = intRead;
        asynI32.getBounds = getIntBounds;
        pinfoPvt->int32.interfaceType = asynInt32Type;
        pinfoPvt->int32.pinterface = (void *)&asynI32;
        pinfoPvt->int32.drvPvt = pinfoPvt;

        status =  pasynInt32Base->initialize(portName, &pinfoPvt->int32);

        if (status == asynSuccess){
                status = pasynManager->registerInterruptSource(
                                portName, &pinfoPvt->int32, &pinfoPvt->pasynInt32Pvt);
        }

        if (status != asynSuccess){
                printf("infoDriverInit registerInterface asynInt32 failed\n");
                return 0;
        }

        return 0;
}

static void report(void *drvPvt, FILE *fp, int details)
{
        infoPvt * pinfoPvt = (infoPvt *)drvPvt;
        int i,n;

        fprintf(fp, "infoDriver connected:%s delay = %f\n",
                        pinfoPvt->connected ? "Yes": "NO",
                        pinfoPvt->delay);
}


static asynStatus connect(void *drvPvt, asynUser * pasynUser)
{
        infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
        deviceInfo      *pdeviceInfo;
        int             addr;
        asynStatus      status;

        status = pasynManager->getAddr(pasynUser, &addr);
        if (status != asynSuccess) return status;

        asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s infoDriver: connect addr %d\n",
                        pinfoPvt->portName, addr);

        if (pinfoPvt->connected){
                asynPrint(pasynUser, ASYN_TRACE_ERROR,
                                "%s infoDriver: connect port already connected\n",
                                pinfoPvt->portName);
                return asynError;
        }

        if (pinfoPvt->delay > 0.0){
                epicsThreadSleep(pinfoPvt->delay * 10.);
        }
        pinfoPvt->connected = 1;
        pinfoPvt->device.connected = 1;
        pasynManager->exceptionConnect(pasynUser);

        return asynSuccess;
}

static asynStatus disconnect(void *drvPvt, asynUser *pasynUser)
{
        infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
        deviceInfo      *pdeviceInfo;
        int             addr;
        asynStatus      status;

        status = pasynManager->getAddr(pasynUser, &addr);
        if (status != asynSuccess) return status;
        asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s infoDriver: disconnect addr %d\n",
                        pinfoPvt->portName, addr);

        if (!pinfoPvt->connected){
                asynPrint(pasynUser, ASYN_TRACE_ERROR,
                                "%s infoDriver: disconnect port not connected\n",
                                pinfoPvt->portName);
                return asynError;
        }

        pinfoPvt->connected = 0;
        pinfoPvt->device.connected = 0;
        pasynManager->exceptionDisconnect(pasynUser);

        return asynSuccess;
}

static asynStatus infoWrite(void *drvPvt, asynUser *pasynUser,
                const char *data, size_t nchars, size_t *nbytesTransfered)
{
        infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
        deviceInfo      *pdeviceInfo;
        deviceBuffer    *pdeviceBuffer;
        int             addr;
        asynStatus      status;

        //printf("infoWrite: %s\n", data);
        status = pasynManager->getAddr(pasynUser, &addr);
        if(status != asynSuccess)       return status;
        addr = 0;
        asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s initDriver: write addr %d\n",
                        pinfoPvt->portName, addr);

        pdeviceInfo = &pinfoPvt->device;
        if (!pdeviceInfo->connected){
                asynPrint(pasynUser, ASYN_TRACE_ERROR, "%s infoDriver: write %d not connected\n", pinfoPvt->portName, addr);
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                "%s infoDriver:write device %d not connected",
                                pinfoPvt->portName, addr);
                return asynError;
        }

        if (pinfoPvt->delay > pasynUser->timeout){
                if (pasynUser->timeout > 0.0) epicsThreadSleep(pasynUser->timeout);
                asynPrint(pasynUser, ASYN_TRACE_ERROR,
                                "%s initDriver write timeout\n", pinfoPvt->portName);
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                "%s infoDriver write timeout", pinfoPvt->portName);

                return asynTimeout;
        }

        pdeviceBuffer = &pdeviceInfo->buffer;
        if(nchars > BUFFERSIZE) nchars = BUFFERSIZE;
        if(nchars > 0){
                memcpy(pdeviceBuffer, data, nchars);
        }
        asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, data, nchars,
                                "infoWrite nchars %lu\n", (unsigned long)nchars);
        pdeviceBuffer->nchars = nchars;
        if (pinfoPvt->delay > 0.0) {
                epicsThreadSleep(pinfoPvt->delay);
        }
        *nbytesTransfered = nchars;
        return status;
}

static asynStatus infoRead(void *drvPvt, asynUser *pasynUser, char *data,
                size_t maxchars, size_t *nbytesTransfered,int *eomReason)
{
        infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
        deviceInfo      *pdeviceInfo;
        deviceBuffer    *pdeviceBuffer;
        char            *pfrom, *pto;
        char            thisChar;
        size_t          nremaining;
        size_t          nout = 0;
        int             addr;
        asynStatus      status;

        if (eomReason) *eomReason = 0;
        if (nbytesTransfered) *nbytesTransfered = 0;
        status = pasynManager->getAddr(pasynUser, &addr);
        addr = 0;

        asynPrint(pasynUser, ASYN_TRACE_FLOW,
                        "%s infoDriver: read addr %d\n", pinfoPvt->portName, addr);
        pdeviceInfo = &pinfoPvt->device;
        if (!pdeviceInfo->connected){
                asynPrint(pasynUser, ASYN_TRACE_ERROR,
                                "%s infoDriver: read device %d not connected\n",
                                pinfoPvt->portName, addr);
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                "%s infoDriver:read device %d not connected",
                                pinfoPvt->portName, addr);

                return asynError;
        }

        if (pinfoPvt->delay > pasynUser->timeout){
                if (pinfoPvt->delay > 0.0){
                        epicsThreadSleep(pasynUser->timeout);
                }
                asynPrint(pasynUser, ASYN_TRACE_ERROR,
                                "%s infoDriver read timeout\n", pinfoPvt->portName);
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                "%s infoDriver read timeout", pinfoPvt->portName);
                return asynTimeout;
        }

        if (pinfoPvt->delay > 0.0){
                epicsThreadSleep(pinfoPvt->delay);
        }

        pdeviceBuffer = &pdeviceInfo->buffer;
        nremaining = pdeviceBuffer->nchars;
        pdeviceBuffer->nchars = 0;
        pfrom = pdeviceBuffer->buffer;
        pto = data;

        while (nremaining >0 && nout < maxchars){
                thisChar = *pto++ = *pfrom++;
                nremaining--;
                nout++;

                if (pinfoPvt->eoslen > 0){
                        if (thisChar == pinfoPvt->eos[0]){
                                if (pinfoPvt->eoslen == 1){
                                        if (eomReason) * eomReason |= ASYN_EOM_EOS;
                                        break;
                                }
                        }
                        if (nremaining == 0){
                                if (eomReason) *eomReason |= ASYN_EOM_CNT;
                                break;
                        }

                        if (* pfrom == pinfoPvt->eos[1]){
                                *pto++ = *pfrom++;
                                nremaining--;
                                nout++;

                                if (eomReason){
                                        *eomReason |= ASYN_EOM_EOS;
                                        if(nremaining == 0){
                                                *eomReason |= ASYN_EOM_CNT;
                                                break;
                                        }
                                }
                        }
                }
        }

        if (nbytesTransfered) *nbytesTransfered = nout;
        if (eomReason){
                if (*nbytesTransfered >= maxchars) *eomReason |= ASYN_EOM_CNT;
                if (nremaining == 0) * eomReason |= ASYN_EOM_END;
        }

        pasynOctetBase->callInterruptUsers(pasynUser, pinfoPvt->pasynPvt, data,
                        nbytesTransfered, eomReason);
        asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, data, nout,
                        "infoRead nbytesTransfered %lu\n", (unsigned long)*nbytesTransfered);
        return status;
}

static asynStatus infoFlush(void *drvPvt, asynUser * pasynUser)
{
        infoPvt *pinfoPvt = (infoPvt *)drvPvt;
        deviceInfo *pdeviceInfo;
        deviceBuffer * pdeviceBuffer;
        int addr;
        asynStatus status;

        status = pasynManager->getAddr(pasynUser, &addr);
        if (status != asynSuccess) return status;

        addr = 0;

        asynPrint(pasynUser, ASYN_TRACE_FLOW,
                        "%s initDriver: flush addr %d\n",
                        pinfoPvt->portName, addr);

        pdeviceInfo = &pinfoPvt->device;
        if (!pdeviceInfo->connected){
                asynPrint(pasynUser, ASYN_TRACE_ERROR,
                                "%s initDriver:flush device %d not connected\n",
                                pinfoPvt->portName, addr);
                return -1;
        }

        pdeviceBuffer = &pdeviceInfo->buffer;
        asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s infoDriver\n", pinfoPvt->portName);
        pdeviceBuffer->nchars = 0;

        return asynSuccess;
}

static asynStatus setEos(void *drvPvt, asynUser * pasynUser, const char *eos, int eoslen)
{
        infoPvt * pinfoPvt = (infoPvt *)drvPvt;
        int i;

        if (eoslen > 2 || eoslen < 0){
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                "setEos illegal eoslen %d", eoslen);
                return asynError;
        }

        pinfoPvt->eoslen = eoslen;
        for (i = 0; i < eoslen; i++){
                pinfoPvt->eos[i] = eos[i];
        }

        asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s setEos\n", pinfoPvt->portName);
        return asynSuccess;
}

static asynStatus getEos(void *drvPvt, asynUser * pasynUser,char *eos, int eossize, int *eoslen)
{
        infoPvt * pinfoPvt = (infoPvt *)drvPvt;
        int i;

        * eoslen = pinfoPvt->eoslen;

        for (i = 0; i < *eoslen; i++){
                eos[i] = pinfoPvt->eos[i];
        }

        asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s setEos\n",
                        pinfoPvt->portName);

        return asynSuccess;
}

static asynStatus intWrite(void *drvPvt, asynUser * pasynUser, epicsInt32 value)
{
         infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
         deviceInfo      *pdeviceInfo;
         deviceBuffer    *pdeviceBuffer;
         int             addr;
         asynStatus      status;

         //printf("infoWrite: %s\n", data);
         status = pasynManager->getAddr(pasynUser, &addr);
         if(status != asynSuccess)       return status;
         addr = 0;
         asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s initDriver: intWrite addr %d\n",
                         pinfoPvt->portName, addr);
         pdeviceInfo = &pinfoPvt->device;
         if (!pdeviceInfo->connected){
                asynPrint(pasynUser, ASYN_TRACE_ERROR, "%s infoDriver: intWrite %d not connected\n", pinfoPvt->portName, addr);
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                 "%s infoDriver:intWrite device %d not connected",
                                 pinfoPvt->portName, addr);
                 return asynError;
         }

         if (pinfoPvt->delay > pasynUser->timeout){
                 if (pasynUser->timeout > 0.0) epicsThreadSleep(pasynUser->timeout);
                 asynPrint(pasynUser, ASYN_TRACE_ERROR,
                                 "%s initDriver intWrite timeout\n", pinfoPvt->portName);
                 epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                 "%s infoDriver intWrite timeout", pinfoPvt->portName);

                 return asynTimeout;
         }

         pdeviceBuffer = &pdeviceInfo->buffer;
         if (value < pdeviceBuffer->low){
                pdeviceBuffer->value = pdeviceBuffer->low;
         }
         else if (value > pdeviceBuffer->high){
                pdeviceBuffer->value = pdeviceBuffer->high;
         }
         else{
                pdeviceBuffer->value = value;
         }

         asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, "Write to device", strlen("Write to device"),
                                 "intWrite value = %d\n", pdeviceBuffer->value);
         if (pinfoPvt->delay > 0.0) {
                 epicsThreadSleep(pinfoPvt->delay);
         }
         return status;
}

static asynStatus intRead(void *drvPvt, asynUser * pasynUser, epicsInt32 *value)
{
         infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
         deviceInfo      *pdeviceInfo;
         deviceBuffer    *pdeviceBuffer;
         int             addr;
         asynStatus      status;

         //printf("infoRead: %s\n", data);
         status = pasynManager->getAddr(pasynUser, &addr);
         if(status != asynSuccess)       return status;
         addr = 0;
         asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s initDriver: intRead addr %d\n",
                         pinfoPvt->portName, addr);
         pdeviceInfo = &pinfoPvt->device;
         if (!pdeviceInfo->connected){
                asynPrint(pasynUser, ASYN_TRACE_ERROR, "%s infoDriver: intRead %d not connected\n", pinfoPvt->portName, addr);
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                 "%s infoDriver:intRead device %d not connected",
                                 pinfoPvt->portName, addr);
                 return asynError;
         }

         if (pinfoPvt->delay > pasynUser->timeout){
                 if (pasynUser->timeout > 0.0) epicsThreadSleep(pasynUser->timeout);
                 asynPrint(pasynUser, ASYN_TRACE_ERROR,
                                 "%s initDriver intRead timeout\n", pinfoPvt->portName);
                 epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                 "%s infoDriver intRead timeout", pinfoPvt->portName);

                 return asynTimeout;
         }

         pdeviceBuffer = &pdeviceInfo->buffer;
         * value = pdeviceBuffer->value;

         asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, "Read from device", strlen("Read from device"),
                                 "intRead value = %d\n", pdeviceBuffer->value);
         if (pinfoPvt->delay > 0.0) {
                 epicsThreadSleep(pinfoPvt->delay);
         }
         return status;
}


static asynStatus getIntBounds(void *drvPvt, asynUser * pasynUser, epicsInt32 *low, epicsInt32 *high)
{
         infoPvt         *pinfoPvt = (infoPvt *)drvPvt;
         deviceInfo      *pdeviceInfo;
         deviceBuffer    *pdeviceBuffer;
         int             addr;
         asynStatus      status;

         //printf("getIntBounds: %s\n", data);
         status = pasynManager->getAddr(pasynUser, &addr);
         if(status != asynSuccess)       return status;
         addr = 0;
         asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s initDriver: getIntBounds addr %d\n",
                         pinfoPvt->portName, addr);
         pdeviceInfo = &pinfoPvt->device;
         if (!pdeviceInfo->connected){
                asynPrint(pasynUser, ASYN_TRACE_ERROR, "%s infoDriver: getIntBounds %d not connected\n", pinfoPvt->portName, addr);
                epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                 "%s infoDriver:getIntBounds device %d not connected",
                                 pinfoPvt->portName, addr);
                 return asynError;
         }

         if (pinfoPvt->delay > pasynUser->timeout){
                 if (pasynUser->timeout > 0.0) epicsThreadSleep(pasynUser->timeout);
                 asynPrint(pasynUser, ASYN_TRACE_ERROR,
                                 "%s initDriver getIntBounds timeout\n", pinfoPvt->portName);
                 epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize,
                                 "%s infoDriver getIntBounds timeout", pinfoPvt->portName);

                 return asynTimeout;
         }

         pdeviceBuffer = &pdeviceInfo->buffer;
         * low = pdeviceBuffer->low;
         * high = pdeviceBuffer->high;

         asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, "get limits from device", strlen("get limits from device"),
                                 "getIntBounds low = %d, high = %d\n", pdeviceBuffer->low, pdeviceBuffer->high);
         return status;
}


static void myCallback(asynUser * pasynUser)
{
        printf("In myCallback\n");
        VALUE += 10;
        printf("Go out of myCallback\n");
}

static void mycallbackTimeout(asynUser * pasynUser)
{
        printf("In mycallbackTimeout\n");
        VALUE += 20;
        printf("Go out of mycallbackTimeout\n");
}

int main()
{
        asynUser * pasynUser = NULL;
        const char * portName = "Device";
        asynStatus status;

        pasynUser = pasynManager->createAsynUser(myCallback,mycallbackTimeout);
        pasynUser->timeout = 5.0;

        int ret = infoDriverInit("Device", 1, 0, 0, 1000);
        printf("pointer = 0x%p, ret = %d\n", pasynUser, ret);

        pasynManager->report(stdout, 1, portName);
        status = pasynManager->connectDevice(pasynUser, portName, 0);
        printf("connectDevice: %d\n", status);

        int yesNo;
        status = pasynManager->isMultiDevice(pasynUser, portName, &yesNo);
        printf("Is multiDevice: %s\n", yesNo ? "Yes": "No");

        status = pasynManager->canBlock(pasynUser, &yesNo);
        printf("can block: %s\n", yesNo ? "Yes":"No");

        int addr;
        status = pasynManager->getAddr(pasynUser, &addr);
        char * pn;
        status = pasynManager->getPortName(pasynUser, &pn);
        printf("portName: %s, addr = %d\n", pn, addr);


        asynInterface * pasynInterface = pasynManager->findInterface(pasynUser, asynCommonType,1);
        if (!pasynInterface){
                printf("can not find asynCommon\n");
                return -1;
        }

        asynCommon *pasynCommon = (asynCommon *)pasynInterface->pinterface;
        void * pasynCommonPvt = pasynInterface->drvPvt;

        printf("asynInterface address: 0x%p, asynCommon address: 0x%p\n", pasynInterface, pasynCommon);

        pasynInterface = pasynManager->findInterface(pasynUser, asynOctetType,1);
        if (!pasynInterface){
                printf("can not find asynOctet\n");
                return -1;
        }


        asynOctet *pasynOctet = (asynOctet *)pasynInterface->pinterface;
        void * pasynOctetPvt = pasynInterface->drvPvt;

        printf("asynInterface address: 0x%p, asynOctet address: 0x%p\n", pasynInterface, pasynOctet);

        pasynInterface = pasynManager->findInterface(pasynUser, asynInt32Type, 1);
        if (!pasynInterface){
                printf("can not find asynInt32\n");
                return -1;
        }
        asynInt32 *pasynInt32 = (asynInt32 *)pasynInterface->pinterface;
        void * pasynInt32Pvt = pasynInterface->drvPvt;


        status = pasynCommon->connect(pasynCommonPvt, pasynUser);

        if (status == asynSuccess){
                printf("connect to device successfully\n");
        }
        else{
                printf("failed to connect to device\n");
                return -1;
        }

        pasynCommon->report(pasynCommonPvt, stdout, 1);

        const char * info = "HelloWrold00";
        int wlen;
        char eos[3];
        memset(eos, 0, sizeof(char) * 3);
        printf("setEos to %s\n", "00");
        status = pasynOctet->setInputEos(pasynOctetPvt, pasynUser, "00",2);
        status = pasynOctet->getInputEos(pasynOctetPvt, pasynUser, eos, 3, &wlen);
        printf("getEos %s\n", eos);

        pasynOctet->write(pasynOctetPvt, pasynUser, info ,strlen(info), &wlen);
        printf("Wait for writing completed\n");
        epicsThreadSleep(1);
        printf("write '%s' to device： %d characters\n", info, wlen);

        char buffer[100];
        int rlen;
        memset(buffer, 0 ,sizeof(char) * 100);
        int eom;

        pasynOctet->read(pasynOctetPvt, pasynUser, buffer, 100, &rlen, &eom);
        printf("Wait for reading completed\n");
        epicsThreadSleep(1);
        printf("read '%s' from device: %d characters\n", buffer, rlen);

        printf("Write %d to device\n", 55);
        pasynInt32->write(pasynInt32Pvt, pasynUser, 55);
        printf("Wait for writing completed\n");
        epicsThreadSleep(1);

        int value, low, high;
        value = low = high = 0;
        pasynInt32->getBounds(pasynInt32Pvt, pasynUser, &low, &high);
        pasynInt32->read(pasynInt32Pvt, pasynUser, &value);
        printf("wait for reading completed\n");
        epicsThreadSleep(1);
        printf("low = %d, high = %d, value = %d\n", low, high, value);



        printf("VALUE = %d\n", VALUE);
        printf("call myCallback in the main:\n");
        pasynManager->queueRequest(pasynUser, 1, 1);
        epicsThreadSleep(2.0);
        printf("VALUE = %d\n", VALUE);


        status = pasynCommon->disconnect(pasynCommonPvt, pasynUser);
        if (status == asynSuccess){
                printf("disconnect from device successfully\n");
        }
        else{
                printf("failed to disconnect from device\n");
                return -1;
        }

        return 0;
}

编译运行以上程序，结果如下：

orangepi@orangepi5:~/C_program/host_program/hostApp$ O.linux-aarch64/device
pointer = 0x0x5592903eb8, ret = 0
Device multiDevice:No canBlock:Yes autoConnect:Yes
    enabled:Yes connected:No numberConnects 0
    nDevices 0 nQueued 0 blocked:No
    asynManagerLock:No synchronousLock:Yes
    exceptionActive:No exceptionUsers 1 exceptionNotifys 0
    traceMask:0x1 traceIOMask:0x0 traceInfoMask:0x1
infoDriver connected:NO delay = 1.000000
connectDevice: 0
Is multiDevice: No
can block: Yes
portName: Device, addr = -1
asynInterface address: 0x0x5592905a68, asynCommon address: 0x0x5586884010
asynInterface address: 0x0x55929072b8, asynOctet address: 0x0x7fab28e4c0
connect to device successfully
infoDriver connected:Yes delay = 1.000000
setEos to 00
getEos 00
Wait for writing completed
write 'HelloWrold00' to device： 12 characters
Wait for reading completed
read 'HelloWrold' from device: 10 characters
Write 55 to device
Wait for writing completed
wait for reading completed
low = 0, high = 1000, value = 55
VALUE = 0
call myCallback in the main:
In myCallback
Go out of myCallback
VALUE = 10
disconnect from device successfully