asynStatus isisdaeDriver::readArray(asynUser *pasynUser, const char* functionName, T *value, size_t nElements, size_t *nIn) { int function = pasynUser->reason; asynStatus status = asynSuccess; const char *paramName = NULL; getParamName(function, ¶mName); m_iface->resetMessages(); try { asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, name=%s\n", driverName, functionName, function, paramName); reportMessages(); return status; } catch(const std::exception& ex) { *nIn = 0; epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, error=%s", driverName, functionName, status, function, paramName, ex.what()); reportErrors(ex.what()); return asynError; } }
/** Called when asyn clients call pasynFloat64->write(). * \param[in] pasynUser pasynUser structure that encodes the reason and address. * \param[in] value Value to write. */ asynStatus testErrors::writeFloat64(asynUser *pasynUser, epicsFloat64 value) { int function = pasynUser->reason; asynStatus status = asynSuccess; int itemp; const char *paramName; const char* functionName = "writeFloat64"; /* Get the current error status */ getIntegerParam(P_StatusReturn, &itemp); status = (asynStatus)itemp; /* Fetch the parameter string name for use in debugging */ getParamName(function, ¶mName); /* Set the parameter in the parameter library. */ setDoubleParam(function, value); /* Set the parameter status in the parameter library. */ setParamStatus(function, status); /* Do callbacks so higher layers see any changes */ callParamCallbacks(); if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, value=%f", driverName, functionName, status, function, paramName, value); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, name=%s, value=%f\n", driverName, functionName, function, paramName, value); return status; }
static asynStatus gpibPortAddressedCmd(void *pdrvPvt,asynUser *pasynUser, const char *data, int length) { niport *pniport = (niport *)pdrvPvt; double timeout = pasynUser->timeout; int addr = 0; int actual; asynStatus status; char cmdbuf[2] = {IBUNT,IBUNL}; status = pasynManager->getAddr(pasynUser,&addr); if(status!=asynSuccess) return status; asynPrint(pasynUser,ASYN_TRACE_FLOW, "%s addr %d gpibPortAddressedCmd nchar %d\n", pniport->portName,addr,length); pniport->errorMessage[0] = 0; status = writeAddr(pniport,0,addr,timeout,transferStateIdle); if(status==asynSuccess) { status=writeCmd(pniport,data,length,timeout,transferStateIdle); } if(status!=asynSuccess) { epicsSnprintf(pasynUser->errorMessage,pasynUser->errorMessageSize, "%s writeGpib failed %s",pniport->portName,pniport->errorMessage); } actual = length - pniport->bytesRemainingCmd; asynPrintIO(pasynUser,ASYN_TRACEIO_DRIVER, data,actual,"%s gpibPortAddressedCmd\n",pniport->portName); if(status!=asynSuccess) return status; writeCmd(pniport,cmdbuf,2,timeout,transferStateIdle); return status; }
asynStatus mar345::erase() { int numErase; int i; asynStatus status=asynSuccess; //const char *functionName = "erase"; getIntegerParam(mar345NumErase, &numErase); if (numErase < 1) numErase=1; setIntegerParam(ADStatus, mar345StatusErase); setIntegerParam(mar345NumErased, 0); callParamCallbacks(); for (i=0; i<numErase; i++) { if (epicsEventTryWait(this->abortEventId) == epicsEventWaitOK) { status = asynError; break; } epicsSnprintf(this->toServer, sizeof(this->toServer), "COMMAND ERASE"); writeServer(this->toServer); status = waitForCompletion("SCAN_DATA Ended o.k.", MAR345_COMMAND_TIMEOUT); if (status) break; setIntegerParam(mar345NumErased, i+1); callParamCallbacks(); } setIntegerParam(ADStatus, mar345StatusIdle); setIntegerParam(mar345Erase, 0); callParamCallbacks(); return(status); }
/// Load a db file multiple times substituting a specified macro according to a number range. /// /// The \a dbFile and \a macros arguments are like the normal dbLoadRecords() however /// it is possible to embed a macro within these whose value follows the range \a start to \a stop. /// You can either load the same \a dbFile multiple times with different macros, or even load /// different database files by using \a loopVar as part of the filename. If you want to use a list /// of (non-numeric) substitutions rather than an integer range see dbLoadRecordsList() /// /// The name of the macro to be used for substitution is contained in \a loopVar and needs to be /// reference in an \\ escaped way to make sure EPICS does not try to substitute it too soon. /// as well as the \a macros the \a dbFile is also passed the \a loopVar macro value /// @code /// dbLoadRecordsLoop("file\$(I).db", "P=1,Q=Hello\$(I)", "I", 1, 4) /// @endcode /// /// @param[in] dbFile @copydoc dbLoadRecordsLoopInitArg0 /// @param[in] macros @copydoc dbLoadRecordsLoopInitArg1 /// @param[in] loopVar @copydoc dbLoadRecordsLoopInitArg2 /// @param[in] start @copydoc dbLoadRecordsLoopInitArg3 /// @param[in] stop @copydoc dbLoadRecordsLoopInitArg4 /// @param[in] step @copydoc dbLoadRecordsLoopInitArg5 epicsShareFunc void dbLoadRecordsLoop(const char* dbFile, const char* macros, const char* loopVar, int start, int stop, int step) { char loopVal[32]; if (loopVar == NULL) { dbLoadRecords(dbFile, macros); return; } if (step <= 0) { step = 1; } std::string macros_s, dbFile_s; subMacros(macros_s, macros, loopVar); subMacros(dbFile_s, dbFile, loopVar); MAC_HANDLE* mh = NULL; char macros_exp[1024], dbFile_exp[1024]; macCreateHandle(&mh, NULL); loadMacEnviron(mh); for(int i = start; i <= stop; i += step) { macPushScope(mh); epicsSnprintf(loopVal, sizeof(loopVal), "%d", i); macPutValue(mh, loopVar, loopVal); macExpandString(mh, macros_s.c_str(), macros_exp, sizeof(macros_exp)); macExpandString(mh, dbFile_s.c_str(), dbFile_exp, sizeof(dbFile_exp)); std::ostringstream new_macros; new_macros << macros_exp << (strlen(macros_exp) > 0 ? "," : "") << loopVar << "=" << i; std::cout << "--> (" << i << ") dbLoadRecords(\"" << dbFile_exp << "\",\"" << new_macros.str() << "\")" << std::endl; dbLoadRecords(dbFile_exp, new_macros.str().c_str()); macPopScope(mh); } macDeleteHandle(mh); }
/** Build a file name from component parts. * \param[in] maxChars The size of the fullFileName string. * \param[out] fullFileName The constructed file name including the file path. * * This is a convenience function that constructs a complete file name * from the NDFilePath, NDFileName, NDFileNumber, and * NDFileTemplate parameters. If NDAutoIncrement is true then it increments the * NDFileNumber after creating the file name. */ int asynNDArrayDriver::createFileName(int maxChars, char *fullFileName) { /* Formats a complete file name from the components defined in NDStdDriverParams */ int status = asynSuccess; char filePath[MAX_FILENAME_LEN]; char fileName[MAX_FILENAME_LEN]; char fileTemplate[MAX_FILENAME_LEN]; int fileNumber; int autoIncrement; int len; this->checkPath(); status |= getStringParam(NDFilePath, sizeof(filePath), filePath); status |= getStringParam(NDFileName, sizeof(fileName), fileName); status |= getStringParam(NDFileTemplate, sizeof(fileTemplate), fileTemplate); status |= getIntegerParam(NDFileNumber, &fileNumber); status |= getIntegerParam(NDAutoIncrement, &autoIncrement); if (status) return(status); len = epicsSnprintf(fullFileName, maxChars, fileTemplate, filePath, fileName, fileNumber); if (len < 0) { status |= asynError; return(status); } if (autoIncrement) { fileNumber++; status |= setIntegerParam(NDFileNumber, fileNumber); } return(status); }
/// Read Values as Octet asynStatus ReadASCII::readOctet(asynUser *pasynUser, char *value, size_t maxChars, size_t *nActual, int *eomReason) { //Checks if directory has changed, reads file again if it has int function = pasynUser->reason; asynStatus status = asynSuccess; const char *paramName; const char* functionName = "readOctet"; /* Fetch the parameter string name for possible use in debugging */ getParamName(function, ¶mName); if (function == P_DirBase) { char dirBase[DIR_LENGTH]; getStringParam(P_DirBase, DIR_LENGTH, dirBase); strncpy(value, dirBase, maxChars); *nActual = strlen(dirBase); std::cerr << status << "new dir base " << dirBase << std::endl; } else { status = asynError; epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s function does not have read.", driverName, functionName, status, function, paramName); } return status; }
asynStatus testErrors::doReadArray(asynUser *pasynUser, epicsType *value, size_t nElements, size_t *nIn, int paramIndex, epicsType *pValue) { int function = pasynUser->reason; size_t ncopy = MAX_ARRAY_POINTS; asynStatus status = asynSuccess; const char *functionName = "doReadArray"; /* Get the current error status */ getIntegerParam(P_StatusReturn, (int*)&status); if (nElements < ncopy) ncopy = nElements; if (function == paramIndex) { memcpy(value, pValue, ncopy*sizeof(epicsType)); *nIn = ncopy; } if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d", driverName, functionName, status, function); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d\n", driverName, functionName, function); return status; }
/** Called when asyn clients call pasynOctet->write(). * This function performs actions for some parameters, including NDAttributesFile. * For all parameters it sets the value in the parameter library and calls any registered callbacks.. * \param[in] pasynUser pasynUser structure that encodes the reason and address. * \param[in] value Address of the string to write. * \param[in] nChars Number of characters to write. * \param[out] nActual Number of characters actually written. */ asynStatus asynNDArrayDriver::writeOctet(asynUser *pasynUser, const char *value, size_t nChars, size_t *nActual) { int addr=0; int function = pasynUser->reason; asynStatus status = asynSuccess; const char *functionName = "writeOctet"; status = getAddress(pasynUser, &addr); if (status != asynSuccess) return(status); /* Set the parameter in the parameter library. */ status = (asynStatus)setStringParam(addr, function, (char *)value); if (function == NDAttributesFile) { this->readNDAttributesFile(value); } else if (function == NDFilePath) { this->checkPath(); } /* Do callbacks so higher layers see any changes */ status = (asynStatus)callParamCallbacks(addr, addr); if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, value=%s", driverName, functionName, status, function, value); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, value=%s\n", driverName, functionName, function, value); *nActual = nChars; return status; }
/** Called when asyn clients call pasynFloat64Array->read(). * Returns the value of the P_Waveform or P_TimeBase arrays. * \param[in] pasynUser pasynUser structure that encodes the reason and address. * \param[in] value Pointer to the array to read. * \param[in] nElements Number of elements to read. * \param[out] nIn Number of elements actually read. */ asynStatus testAsynPortDriver::readFloat64Array(asynUser *pasynUser, epicsFloat64 *value, size_t nElements, size_t *nIn) { int function = pasynUser->reason; size_t ncopy; int itemp; asynStatus status = asynSuccess; const char *functionName = "readFloat64Array"; getIntegerParam(P_MaxPoints, &itemp); ncopy = itemp; if (nElements < ncopy) ncopy = nElements; if (function == P_Waveform) { memcpy(value, pData_, ncopy*sizeof(epicsFloat64)); *nIn = ncopy; } else if (function == P_TimeBase) { memcpy(value, pTimeBase_, ncopy*sizeof(epicsFloat64)); *nIn = ncopy; } if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d", driverName, functionName, status, function); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d\n", driverName, functionName, function); return status; }
/* * asynOctet methods */ static asynStatus writeIt(void *drvPvt, asynUser *pasynUser, const char *data, size_t numchars,size_t *nbytesTransfered) { usbController_t *usb = (usbController_t *)drvPvt; double cmdstr[3]; unsigned char cmd[3]; assert(usb); asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s write.\n", usb->usbDeviceName); asynPrintIO(pasynUser, ASYN_TRACEIO_DRIVER, data, numchars, "%s write %d\n", usb->usbDeviceName, numchars); if (usb->dev == NULL) { epicsSnprintf(pasynUser->errorMessage,pasynUser->errorMessageSize, "%s disconnected:", usb->usbDeviceName); return asynError; } if (sscanf(data, "%lf %lf %lf", &cmdstr[0], &cmdstr[1], &cmdstr[2])!=3) return asynError; cmd[0] = cmdstr[0]; cmd[1] = cmdstr[1]; cmd[2] = cmdstr[2]; if (numchars!=3) numchars = 3; *nbytesTransfered = 0; *nbytesTransfered = libusb_control_transfer(usb->handle, 0x40, 6, 0x100, 0, cmd, (uint16_t)numchars, 0); if (*nbytesTransfered>=numchars) return asynSuccess; else return asynError; return asynSuccess; }
/**Enables or disables the flipping of the channel numbering. **/ asynStatus mythen::setBitDepth(epicsInt32 value) { asynStatus status; epicsInt32 nbits; switch (value) { case 0: nbits = 24; break; case 1: nbits = 16; break; case 2: nbits = 8; break; case 3: nbits = 4; break; default: nbits = 24; break; } epicsSnprintf(outString_, sizeof(outString_), "-nbits %d", nbits); status = sendCommand(); return status; }
static int writeString(gpibDpvt *pgpibDpvt,int P1, int P2, char **P3) { asynUser *pasynUser = pgpibDpvt->pasynUser; stringoutRecord *precord = (stringoutRecord*)pgpibDpvt->precord; int nchars; gpibCmd *pgpibCmd = gpibCmdGet(pgpibDpvt); char *format = (pgpibCmd->format) ? pgpibCmd->format : "%s"; if(!pgpibDpvt->msg) { asynPrint(pasynUser,ASYN_TRACE_ERROR, "%s no msg buffer. Must define gpibCmd.msgLen > 0.\n", precord->name); recGblSetSevr(precord,WRITE_ALARM, INVALID_ALARM); return -1; } nchars = epicsSnprintf(pgpibDpvt->msg,pgpibCmd->msgLen,format,precord->val); if(nchars>pgpibCmd->msgLen) { asynPrint(pasynUser,ASYN_TRACE_ERROR, "%s msg buffer too small. msgLen %d message length %d\n", precord->name,pgpibCmd->msgLen,nchars); recGblSetSevr(precord,WRITE_ALARM, INVALID_ALARM); return -1; } asynPrint(pasynUser,ASYN_TRACE_FLOW,"%s writeMsgString\n",precord->name); return nchars; }
/** Called when asyn clients call pasynInt32->write(). * This function sends a signal to the arrayGenTask thread if the value of P_RunStop has changed. * For all parameters it sets the value in the parameter library and calls any registered callbacks.. * \param[in] pasynUser pasynUser structure that encodes the reason and address. * \param[in] value Value to write. */ asynStatus testArrayRingBuffer::writeInt32(asynUser *pasynUser, epicsInt32 value) { int function = pasynUser->reason; asynStatus status = asynSuccess; const char *paramName; const char* functionName = "writeInt32"; /* Set the parameter in the parameter library. */ status = (asynStatus) setIntegerParam(function, value); /* Fetch the parameter string name for possible use in debugging */ getParamName(function, ¶mName); if (function == P_RunStop) { if (value) epicsEventSignal(eventId_); } else { /* All other parameters just get set in parameter list, no need to * act on them here */ } /* Do callbacks so higher layers see any changes */ status = (asynStatus) callParamCallbacks(); if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, value=%d", driverName, functionName, status, function, paramName, value); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, name=%s, value=%d\n", driverName, functionName, function, paramName, value); return status; }
static void testEpicsSnprintf(void) { char exbuffer[80], buffer[80]; const int ivalue = 1234; const float fvalue = 1.23e4f; const char *svalue = "OneTwoThreeFour"; const char *format = "int %d float %8.2e string %s"; const char *expected = exbuffer; int size; int rtn, rlen; sprintf(exbuffer, format, ivalue, fvalue, svalue); rlen = strlen(expected)+1; strcpy(buffer, "AAAA"); for (size = 1; size < strlen(expected) + 5; ++size) { rtn = epicsSnprintf(buffer, size, format, ivalue, fvalue, svalue); testOk(rtn <= rlen-1, "epicsSnprintf(size=%d) = %d", size, rtn); if (rtn != rlen-1) testDiag("Return value does not indicate buffer size needed"); testOk(strncmp(buffer, expected, size - 1) == 0, "buffer = '%s'", buffer); rtn = strlen(buffer); testOk(rtn == (size < rlen ? size : rlen) - 1, "length = %d", rtn); } }
/* * Double up IAC characters. * We assume that memchr and memcpy are nicely optimized so we're better of * using them than looking at and copying the characters one at a time ourself. */ static asynStatus writeIt(void *ppvt, asynUser *pasynUser, const char *data, size_t numchars, size_t *nbytesTransfered) { interposePvt *pinterposePvt = (interposePvt *)ppvt; const char *iac; char *dst = pinterposePvt->xBuf; size_t nIAC = 0; asynStatus status; if ((iac = memchr(data, C_IAC, numchars)) != NULL) { size_t nLeft = numchars; size_t nCopy = iac - data + 1; for (;;) { size_t nNew = nCopy + 1; char *np; if (nNew > pinterposePvt->xBufCapacity) { /* * Try to strike a balance between too many * realloc calls and too much wasted space. */ size_t newSize = pinterposePvt->xBufCapacity + 1024; if (newSize < numchars) newSize = numchars + 1024; if (newSize < nNew) newSize = nNew + 1024; np = realloc(pinterposePvt->xBuf, newSize); if (np == NULL) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "Out of memory"); return asynError; } dst = np + (dst - pinterposePvt->xBuf); pinterposePvt->xBuf = np; pinterposePvt->xBufCapacity = newSize; } memcpy(dst, data, nCopy); dst += nCopy; if (iac != NULL) { *dst++ = C_IAC; nIAC++; } nLeft -= nCopy; if (nLeft == 0) break; data += nCopy; if ((iac = memchr(data, C_IAC, nLeft)) != NULL) nCopy = iac - data + 1; else nCopy = nLeft; } numchars += nIAC; data = pinterposePvt->xBuf; } status = pinterposePvt->pasynOctetDrv->write(pinterposePvt->drvPvt, pasynUser, data, numchars, nbytesTransfered); if (*nbytesTransfered == numchars) *nbytesTransfered -= nIAC; return status; }
/** Called when asyn clients call pasynUInt32D->write(). * For all parameters it sets the value in the parameter library and calls any registered callbacks.. * \param[in] pasynUser pasynUser structure that encodes the reason and address. * \param[in] value Value to write. */ asynStatus testErrors::writeUInt32Digital(asynUser *pasynUser, epicsUInt32 value, epicsUInt32 mask) { int function = pasynUser->reason; asynStatus status = asynSuccess; const char *paramName; const char* functionName = "writeUInt32D"; /* Get the current error status */ getIntegerParam(P_StatusReturn, (int*)&status); /* Fetch the parameter string name for use in debugging */ getParamName(function, ¶mName); /* Set the parameter value in the parameter library. */ setUIntDigitalParam(function, value, mask); /* Set the parameter status in the parameter library. */ setParamStatus(function, status); /* Do callbacks so higher layers see any changes */ callParamCallbacks(); if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, value=0x%X", driverName, functionName, status, function, paramName, value); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, name=%s, value=0x%X\n", driverName, functionName, function, paramName, value); return status; }
static asynStatus uint32Read(void *pvt,asynUser *pasynUser, epicsUInt32 *value,epicsUInt32 mask) { drvPvt *pdrvPvt = (drvPvt *)pvt; int addr; asynStatus status; status = getAddr(pdrvPvt,pasynUser,&addr,0); if(status!=asynSuccess) return status; asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s %d uint32DigitalDriver:readInt32\n",pdrvPvt->portName,addr); if(!pdrvPvt->connected) { asynPrint(pasynUser,ASYN_TRACE_ERROR, "%s uint32DigitalDriver:read not connected\n",pdrvPvt->portName); epicsSnprintf(pasynUser->errorMessage,pasynUser->errorMessageSize, "%s uint32DigitalDriver:read not connected",pdrvPvt->portName); return asynError; } epicsMutexMustLock(pdrvPvt->lock); *value = mask & pdrvPvt->channel[addr].value; epicsMutexUnlock(pdrvPvt->lock); asynPrint(pasynUser,ASYN_TRACEIO_DRIVER, "%s read %d\n",pdrvPvt->portName,*value); return asynSuccess; }
/** Called when asyn clients call pasynOctet->write(). * Simply sets the value in the parameter library and * calls any registered callbacks for this pasynUser->reason and address. * \param[in] pasynUser pasynUser structure that encodes the reason and address. * \param[in] value Address of the string to write. * \param[in] nChars Number of characters to write. * \param[out] nActual Number of characters actually written. */ asynStatus testErrors::writeOctet(asynUser *pasynUser, const char *value, size_t nChars, size_t *nActual) { int function = pasynUser->reason; asynStatus status = asynSuccess; const char *functionName = "writeOctet"; /* Get the current error status */ getIntegerParam(P_StatusReturn, (int*)&status); /* Set the parameter in the parameter library. */ setStringParam(function, (char *)value); /* Set the parameter status in the parameter library. */ setParamStatus(function, status); /* Do callbacks so higher layers see any changes */ callParamCallbacks(); if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, value=%s", driverName, functionName, status, function, value); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, value=%s\n", driverName, functionName, function, value); *nActual = nChars; return status; }
static asynStatus float64Read(void *pvt,asynUser *pasynUser, epicsFloat64 *value) { drvPvt *pdrvPvt = (drvPvt *)pvt; int addr; asynStatus status; status = getAddr(pdrvPvt,pasynUser,&addr,0); if(status!=asynSuccess) return status; asynPrint(pasynUser, ASYN_TRACE_FLOW, "%s %d uint32DigitalDriver:float64Read\n",pdrvPvt->portName,addr); if(!pdrvPvt->connected) { asynPrint(pasynUser,ASYN_TRACE_ERROR, "%s uint32DigitalDriver:read not connected\n",pdrvPvt->portName); epicsSnprintf(pasynUser->errorMessage,pasynUser->errorMessageSize, "%s uint32DigitalDriver:read not connected",pdrvPvt->portName); return asynError; } epicsMutexMustLock(pdrvPvt->lock); *value = pdrvPvt->interruptDelay; epicsMutexUnlock(pdrvPvt->lock); asynPrint(pasynUser,ASYN_TRACEIO_DRIVER, "%s read %f\n",pdrvPvt->portName,*value); return asynSuccess; }
/** Sets an int32 parameter. * \param[in] pasynUser asynUser structure that contains the function code in pasynUser->reason. * \param[in] value The value for this parameter * * Takes action if the function code requires it. */ asynStatus NDPosPlugin::writeInt32(asynUser *pasynUser, epicsInt32 value) { int function = pasynUser->reason; int oldvalue; int addr; asynStatus status = asynSuccess; static const char *functionName = "NDPosPlugin::writeInt32"; // Set the parameter in the parameter library. status = getAddress(pasynUser, &addr); if (status == asynSuccess){ getIntegerParam(function, &oldvalue); // By default we set the value in the parameter library. If problems occur we set the old value back. setIntegerParam(function, value); if (function == NDPos_Running){ // Reset the expected ID to the starting value int expected = 0; getIntegerParam(NDPos_IDStart, &expected); setIntegerParam(NDPos_ExpectedID, expected); } else if (function == NDPos_Mode){ // Reset the position index to 0 if the mode is changed setIntegerParam(NDPos_CurrentIndex, 0); } else if (function == NDPos_Restart){ // Reset the position index to 0 setIntegerParam(NDPos_CurrentIndex, 0); // Reset the last sent position setStringParam(NDPos_CurrentPos, ""); } else if (function == NDPos_Delete){ // Reset the position index to 0 setIntegerParam(NDPos_CurrentIndex, 0); // Reset the last sent position setStringParam(NDPos_CurrentPos, ""); // Clear out the position array positionArray.clear(); setIntegerParam(NDPos_CurrentQty, positionArray.size()); } else { // If this parameter belongs to a base class call its method if (function < FIRST_NDPOS_PARAM){ status = NDPluginDriver::writeInt32(pasynUser, value); } } } // Do callbacks so higher layers see any changes status = (asynStatus)callParamCallbacks(); if (status){ epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s: status=%d, function=%d, value=%d", functionName, status, function, value); } else { asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s: function=%d, value=%d\n", functionName, function, value); } return status; }
/** Base method for closing a file * Calls the pure virtual function closeFile in the derived class. */ asynStatus NDPluginFile::closeFileBase() { /* Closes a file */ asynStatus status = asynSuccess; char errorMessage[256]; const char* functionName = "closeFileBase"; setIntegerParam(NDFileWriteStatus, NDFileWriteOK); setStringParam(NDFileWriteMessage, ""); /* Call the closeFile method in the derived class */ epicsMutexLock(this->fileMutexId); status = this->closeFile(); if (status) { epicsSnprintf(errorMessage, sizeof(errorMessage)-1, "Error closing file, status=%d", status); asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, "%s:%s %s\n", driverName, functionName, errorMessage); setIntegerParam(NDFileWriteStatus, NDFileWriteError); setStringParam(NDFileWriteMessage, errorMessage); } epicsMutexUnlock(this->fileMutexId); return(status); }
/** This method copies an NDArray object from the asynNDArrayDriver to an NDArray pointer passed in by the caller. * The destination NDArray address is passed by the caller in the genericPointer argument. The caller * must allocate the memory for the array, and pass the size in NDArray->dataSize. * The method will limit the amount of data copied to the actual array size or the * input dataSize, whichever is smaller. * \param[in] pasynUser Used to obtain the addr for the NDArray to be copied from, and for asynTrace output. * \param[out] genericPointer Pointer to an NDArray. The NDArray must have been previously allocated by the caller. * The NDArray from the asynNDArrayDriver will be copied into the NDArray pointed to by genericPointer. */ asynStatus asynNDArrayDriver::readGenericPointer(asynUser *pasynUser, void *genericPointer) { NDArray *pArray = (NDArray *)genericPointer; NDArray *myArray; NDArrayInfo_t arrayInfo; int addr; asynStatus status = asynSuccess; const char* functionName = "readNDArray"; status = getAddress(pasynUser, &addr); if (status != asynSuccess) return(status); this->lock(); myArray = this->pArrays[addr]; if (!myArray) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: error, no valid array available, pData=%p", driverName, functionName, pArray->pData); status = asynError; } else { this->pNDArrayPool->copy(myArray, pArray, 0); myArray->getInfo(&arrayInfo); if (arrayInfo.totalBytes > pArray->dataSize) arrayInfo.totalBytes = pArray->dataSize; memcpy(pArray->pData, myArray->pData, arrayInfo.totalBytes); } if (!status) asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: error, maxBytes=%lu, data=%p\n", driverName, functionName, (unsigned long)arrayInfo.totalBytes, pArray->pData); this->unlock(); return status; }
asynStatus isisdaeDriver::readValue(asynUser *pasynUser, const char* functionName, T* value) { int function = pasynUser->reason; asynStatus status = asynSuccess; const char *paramName = NULL; getParamName(function, ¶mName); m_iface->resetMessages(); try { status = asynPortDriver::readValue(pasynUser, functionName, &value); asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, name=%s, value=%s\n", driverName, functionName, function, paramName, convertToString(*value).c_str()); reportMessages(); return status; } catch(const std::exception& ex) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, value=%s, error=%s", driverName, functionName, status, function, paramName, convertToString(*value).c_str(), ex.what()); reportErrors(ex.what()); return asynError; } }
asynStatus ReadASCII::writeOctet(asynUser *pasynUser, const char *value, size_t maxChars, size_t *nActual) { //Checks if directory has changed, reads file again if it has int function = pasynUser->reason; int status = asynSuccess; const char *paramName; const char* functionName = "writeOctet"; /* Set the parameter in the parameter library. */ status = (asynStatus)setStringParam(function, value); /* Fetch the parameter string name for possible use in debugging */ getParamName(function, ¶mName); if (function == P_Dir | function == P_DirBase) { // Directory has changed so update status |= readFileBasedOnParameters(); } /* Do callbacks so higher layers see any changes */ status |= (asynStatus)callParamCallbacks(); if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, value=%d", driverName, functionName, status, function, paramName, value); *nActual = maxChars; return (asynStatus)status; }
asynStatus NetShrVarDriver::writeArrayValue(asynUser *pasynUser, const char* functionName, T* value, size_t nElements) { int function = pasynUser->reason; asynStatus status = asynSuccess; const char *paramName = NULL; getParamName(function, ¶mName); try { if (m_netvarint == NULL) { throw std::runtime_error("m_netvarint is NULL"); } m_netvarint->setArrayValue(paramName, value, nElements); asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, name=%s, nElements=%d\n", driverName, functionName, function, paramName, (int)nElements); return asynSuccess; } catch(const std::exception& ex) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, nElements=%d, error=%s", driverName, functionName, status, function, paramName, (int)nElements, ex.what()); return asynError; } }
asynStatus ReadASCII::writeInt32(asynUser *pasynUser, epicsInt32 value) { //Checks for updates to the index and on/off of PID lookup int function = pasynUser->reason; asynStatus status = asynSuccess; const char *paramName; const char* functionName = "writeInt32"; int LUTOn; /* Set the parameter in the parameter library. */ status = (asynStatus)setIntegerParam(function, value); if (function == P_Index) { //check lookup on getIntegerParam(P_LookUpOn, &LUTOn); if (LUTOn) { //update all column floats setDoubleParam(P_SPOut, pSP_[value]); setDoubleParam(P_P, pP_[value]); setDoubleParam(P_I, pI_[value]); setDoubleParam(P_D, pD_[value]); setDoubleParam(P_MaxHeat, pMaxHeat_[value]); } }else if (function == P_LookUpOn) { //reload file if bad if (true == fileBad) { status = readFileBasedOnParameters(); } //file may now be good - retry if (false == fileBad) { //uses the current temperature to find PID values if (value) { double curTemp; getDoubleParam(P_CurTemp, &curTemp); updatePID(getSPInd(curTemp)); } } } /* Do callbacks so higher layers see any changes */ status = (asynStatus)callParamCallbacks(); if (status) epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, value=%d", driverName, functionName, status, function, paramName, value); else asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, name=%s, value=%d\n", driverName, functionName, function, paramName, value); return status; }
/**************************************************************************** * Define private interface asynDrvUser methods ****************************************************************************/ static asynStatus create(void* ppvt,asynUser* pasynUser,const char* drvInfo, const char** pptypeName,size_t* psize) { int i,addr; asynStatus sts; Inst* pinst; Port* pport = (Port*)ppvt; asynPrint(pasynUser,ASYN_TRACE_FLOW,"drvLove::create\n"); sts = pasynManager->getAddr(pasynUser,&addr); if( ISNOTOK(sts) ) return( sts ); for( i = 0; i < cmdCount; ++i ) { if( epicsStrCaseCmp(CmdTable[i].pname,drvInfo) == 0 ) { pinst = callocMustSucceed(sizeof(Inst),sizeof(char),"drvLove::create"); pinst->pport = pport; pinst->pinfo = &pport->instr[addr-1]; pinst->read = CmdTable[i].read; pinst->write = CmdTable[i].write; pinst->pcmd = &CmdTable[i].strings[pinst->pinfo->modidx]; pasynUser->drvUser = (void*)pinst; return( asynSuccess ); } } epicsSnprintf(pasynUser->errorMessage,pasynUser->errorMessageSize,"failure to find command %s",drvInfo); return( asynError ); }
asynStatus NetShrVarDriver::writeOctet(asynUser *pasynUser, const char *value, size_t maxChars, size_t *nActual) { int function = pasynUser->reason; asynStatus status = asynSuccess; const char *paramName = NULL; getParamName(function, ¶mName); const char* functionName = "writeOctet"; std::string value_s(value, maxChars); try { if (m_netvarint == NULL) { throw std::runtime_error("m_netvarint is NULL"); } m_netvarint->setValue(paramName, value_s); asynPrint(pasynUser, ASYN_TRACEIO_DRIVER, "%s:%s: function=%d, name=%s, value=%s\n", driverName, functionName, function, paramName, value_s.c_str()); *nActual = value_s.size(); return asynPortDriver::writeOctet(pasynUser, value_s.c_str(), maxChars, nActual); } catch(const std::exception& ex) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "%s:%s: status=%d, function=%d, name=%s, value=%s, error=%s", driverName, functionName, status, function, paramName, value_s.c_str(), ex.what()); *nActual = 0; return asynError; } }
static int Up550_convertPVReplyAI(struct gpibDpvt *pdpvt, int P1, int P2, char **P3) { struct aiRecord *pai = ((struct aiRecord *)(pdpvt->precord)); asynOctet *pasynOctet =pdpvt->pasynOctet; void *asynOctetPvt = pdpvt->asynOctetPvt; int len; int rval; char cmd[64] = {0,}; char cbuf[64] = {0,}; int addr; addr = pai->inp.value.gpibio.addr; if(addr == 1) make_Up550_commandString(3, "WRD0003,01", cmd); /* PV.1 value */ else if(addr == 2) make_Up550_commandString(3, "WRD0019,01", cmd); /* PV.2 value */ if((pasynOctet->setInputEos(asynOctetPvt,pdpvt->pasynUser,NULL,0) != asynSuccess)) return -1; if((pasynOctet->setOutputEos(asynOctetPvt,pdpvt->pasynUser,NULL,0) != asynSuccess)) return -1; if(pasynOctet->write(asynOctetPvt,pdpvt->pasynUser,cmd,strlen(cmd),&len) != asynSuccess) return -1; pasynOctet->read(asynOctetPvt,pdpvt->pasynUser,cbuf, sizeof(cbuf),&len, NULL); if (len < 15){ /* invalid length */ epicsSnprintf(pdpvt->pasynUser->errorMessage, pdpvt->pasynUser->errorMessageSize, "Invalid reply %d", pdpvt->msgInputLen); return -1; } if (check_validReply(cbuf, len) < 0) { /* invalid reply data */ epicsSnprintf(pdpvt->pasynUser->errorMessage, pdpvt->pasynUser->errorMessageSize, "Invalid reply %d", pdpvt->msgInputLen); return -1; } float val; sscanf(cbuf+7, "%4X", &rval); val = rval / 10.0; pai->val = val; pai->udf = 0; return 0; }