From ccd73babd535417f30432ed7872a793e455c7ebd Mon Sep 17 00:00:00 2001 From: koennecke Date: Tue, 21 Mar 2023 14:55:07 +0100 Subject: [PATCH] First working version of the MasterMACS EPICS driver Also added some test code --- sinqEPICSApp/src/MasterMACSDriver.cpp | 820 + sinqEPICSApp/src/MasterMACSDriver.h | 71 + testmmac/db/asynRecord.db | 9 + testmmac/db/basic_asyn_motor.db | 23 + testmmac/db/basic_motor.db | 21 + testmmac/db/motorMessage.db | 18 + testmmac/db/pmacV3.db | 14 + testmmac/db/sinq_asyn_motor.db | 47 + testmmac/mmacs.sub | 15 + testmmac/mmacs2.sub | 8 + testmmac/mota.sub | 13 + testmmac/motaspeed.sub | 12 + testmmac/testmmacs.cmd | 19 + testpmacV3/db/asynRecord.db | 9 + testpmacV3/db/basic_asyn_motor.db | 22 + testpmacV3/db/huber.dbd | 19544 ++++++++++++++++++++++++ testpmacV3/db/motorMessage.db | 9 + testpmacV3/db/pmacV3.db | 14 + testpmacV3/mcu.substitutions | 27 + testpmacV3/st.cmd | 25 + utils/macmaster.py | 53 + utils/syncMasterMAC.py | 90 + 22 files changed, 20883 insertions(+) create mode 100644 sinqEPICSApp/src/MasterMACSDriver.cpp create mode 100644 sinqEPICSApp/src/MasterMACSDriver.h create mode 100644 testmmac/db/asynRecord.db create mode 100644 testmmac/db/basic_asyn_motor.db create mode 100644 testmmac/db/basic_motor.db create mode 100644 testmmac/db/motorMessage.db create mode 100644 testmmac/db/pmacV3.db create mode 100644 testmmac/db/sinq_asyn_motor.db create mode 100644 testmmac/mmacs.sub create mode 100644 testmmac/mmacs2.sub create mode 100644 testmmac/mota.sub create mode 100644 testmmac/motaspeed.sub create mode 100755 testmmac/testmmacs.cmd create mode 100644 testpmacV3/db/asynRecord.db create mode 100644 testpmacV3/db/basic_asyn_motor.db create mode 100644 testpmacV3/db/huber.dbd create mode 100644 testpmacV3/db/motorMessage.db create mode 100644 testpmacV3/db/pmacV3.db create mode 100644 testpmacV3/mcu.substitutions create mode 100755 testpmacV3/st.cmd create mode 100644 utils/macmaster.py create mode 100755 utils/syncMasterMAC.py diff --git a/sinqEPICSApp/src/MasterMACSDriver.cpp b/sinqEPICSApp/src/MasterMACSDriver.cpp new file mode 100644 index 0000000..7add320 --- /dev/null +++ b/sinqEPICSApp/src/MasterMACSDriver.cpp @@ -0,0 +1,820 @@ +/* + Driver for the MasterMACS motor controller used at SINQ + For documentation see the standard SINQ place for hardware documentation or + Marcel Schildt + + Mark Koennecke, March 2023 +*/ + + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include "MasterMACSDriver.h" +#include + +#define IDLEPOLL 60 + +#define CHECK_BIT(var,pos) ((var) & (1 << pos)) +#define ABS(x) (x < 0 ? -(x) : (x)) + +/** Creates a new MasterMACSController object. + * \param[in] portName The name of the asyn port that will be created for this driver + * \param[in] MasterMACSPortName The name of the drvAsynSerialPort that was created previously to connect to the MasterMACS controller + * \param[in] numAxes The number of axes that this controller supports + */ +MasterMACSController::MasterMACSController(const char *portName, + const char *MasterMACSPortName, + int + numAxes):SINQController + (portName, MasterMACSPortName, numAxes) +{ + asynStatus status; + static const char *functionName = + "MasterMACSController::MasterMACSController"; + char terminator[2] = "\x03"; + + + /* Connect to MasterMACS controller */ + status = + pasynOctetSyncIO->connect(MasterMACSPortName, 0, + &pasynUserController_, NULL); + if (status) { + asynPrint(this->pasynUserSelf, ASYN_TRACE_ERROR, + "%s: cannot connect to MasterMACS controller\n", + functionName); + } + pasynOctetSyncIO->setOutputEos(pasynUserController_, terminator, + strlen(terminator)); + pasynOctetSyncIO->setInputEos(pasynUserController_, terminator, + strlen(terminator)); + + + pAxes_ = (MasterMACSAxis **) (asynMotorController::pAxes_); + createParam(EnableAxisString, asynParamInt32, &enableAxis_); + createParam(AxisEnabledString, asynParamInt32, &axisEnabled_); + callParamCallbacks(); + + startPoller(1000. / 1000., IDLEPOLL, 2); +} + + +/** Creates a new MasterMACSController object. + * Configuration command, called directly or from iocsh + * \param[in] portName The name of the asyn port that will be created for this driver + * \param[in] MasterMACSPortName The name of the drvAsynIPPPort that was created previously to connect to the MasterMACS controller + * \param[in] numAxes The number of axes that this controller supports + */ +extern "C" int +MasterMACSCreateController(const char *portName, + const char *MasterMACSPortName, int numAxes) +{ + MasterMACSController *pMasterMACSController + = new MasterMACSController(portName, MasterMACSPortName, numAxes); + pMasterMACSController = NULL; + return (asynSuccess); +} + +/** Reports on status of the driver + * \param[in] fp The file pointer on which report information will be written + * \param[in] level The level of report detail desired + * + * If details > 0 then information is printed about each axis. + * After printing controller-specific information it calls asynMotorController::report() + */ +void + MasterMACSController::report(FILE * fp, int level) +{ + fprintf(fp, "MasterMACS motor driver %s, numAxes=%d\n", + this->portName, numAxes_); + + // Call the base class method + asynMotorController::report(fp, level); +} + +/** Returns a pointer to an MasterMACSAxis object. + * Returns NULL if the axis number encoded in pasynUser is invalid. + * \param[in] pasynUser asynUser structure that encodes the axis index number. */ +MasterMACSAxis *MasterMACSController::getAxis(asynUser * pasynUser) +{ + return static_cast < + MasterMACSAxis * >(asynMotorController::getAxis(pasynUser)); +} + +/** Returns a pointer to an MasterMACSAxis object. + * Returns NULL if the axis number encoded in pasynUser is invalid. + * \param[in] axisNo Axis index number. */ +MasterMACSAxis *MasterMACSController::getAxis(int axisNo) +{ + return static_cast < + MasterMACSAxis * >(asynMotorController::getAxis(axisNo)); +} + +/** + * send a command to the MasterMACS and read the reply. Do some error and controller + * issue fixing on the way + * \param[in] command The command to send + * \param[out] reply The controllers reply + */ + +asynStatus + MasterMACSController::transactController(int axisNo, + char command[COMLEN], + char reply[COMLEN]) +{ + asynStatus status; + size_t in, out; + int reason, len, idx, lenPayload; + unsigned int i; + char *mmacsData = + NULL, ackchar, mmacsResponse[COMLEN], hexResponse[256]; + SINQAxis *axis = getAxis(axisNo); + + pasynOctetSyncIO->flush(pasynUserController_); + /* pack data for MasterMACS */ + len = strlen(command) + 6; + mmacsData = (char *) malloc(len * sizeof(char)); + if (!mmacsData) { + errlogSevPrintf(errlogMajor, + "Failed to allocate memory in MasterMACSController::transactController"); + return asynError; + } + mmacsData[0] = 0x05; + mmacsData[1] = (char) (len - 2); + mmacsData[2] = 0; + mmacsData[3] = 0x19; + memcpy(mmacsData + 4, command, strlen(command) * sizeof(char)); + mmacsData[len - 2] = 0x0D; + /* 0x03 is appended by asyn */ + + /* send the stuff away ... */ + //errlogSevPrintf(errlogMajor,"Sending command: %s\n", command); + + status = + pasynOctetSyncIO->writeRead(pasynUserController_, mmacsData, + len - 1, mmacsResponse, 35, 5., &out, + &in, &reason); + if (status != asynSuccess) { + if (axis != NULL) { + errlogSevPrintf(errlogMajor, + "Lost connection to motor controller, reason %d", + reason); + axis->updateMsgTxtFromDriver + ("Lost connection to motor controller"); + return status; + } + errlogSevPrintf(errlogMajor, + "Lost connection to motor controller without axis, reason %d", + reason); + return status; + } + free(mmacsData); + + /* format and print the response in hex for debugging purposes + for(i = 0, idx = 0; i < in; i++){ + sprintf(hexResponse + idx, "%02x ", (unsigned int)mmacsResponse[i]); + idx = strlen(hexResponse); + } + errlogSevPrintf(errlogMajor,"Reply in hex: %s\n", hexResponse); + */ + + /* Here we have read the data from the MasterMACS. We proceed to extract + * the payload and the state of the ACK byte and place that reply into data + */ + if ((in < 33)) { + errlogSevPrintf(errlogMajor, + "MasterMACS only sent %d bytes, 34 expected", + (int) in); + return asynError; + } + /* + * Unpack the MasterMACS message, start by finding + */ + for (i = 4, idx = 0; i < 34; i++) { + if (mmacsResponse[i] == 0x0d) { + idx = i; + break; + } + } + //errlogSevPrintf(errlogMajor, "Found at %d", idx); + + /* one character before is the ACK, if it is there */ + ackchar = mmacsResponse[idx - 1]; + if (ackchar == 0x06) { + strcpy(reply, "ACK:"); + } else if (ackchar == 0x15) { + strcpy(reply, "NAK:"); + errlogSevPrintf(errlogMajor, + "MasterMACS responded with NAK to %s\n", command); + status = asynError; + } else { + /* the MasterMACS does not always send a ACK/NAK on read */ + strcpy(reply, "NON:"); + } + //errlogSevPrintf(errlogMajor, "Reply after testing ACK byte: %s ", reply); + + /* copy data */ + lenPayload = idx - 4; + memcpy(reply + 4, mmacsResponse + 4, lenPayload); + reply[4 + lenPayload] = (char) 0; + //errlogSevPrintf(errlogMajor, "Completed reply at end of transactController: %s ", reply); + + return status; +} + +asynStatus + MasterMACSController::writeInt32(asynUser * pasynUser, + epicsInt32 value) +{ + int function = pasynUser->reason; + asynStatus status = asynSuccess; + MasterMACSAxis *pAxis = NULL; + char command[64] = { 0 }; + char response[64] = { 0 }; + + pAxis = (MasterMACSAxis *) this->getAxis(pasynUser); + if (!pAxis) { + return asynError; + } + + /* Set the parameter and readback in the parameter library. This may be + * overwritten when we read back the status at the end, but that's OK */ + pAxis->setIntegerParam(function, value); + + if (function == enableAxis_) { + if (value == 1) { + /* download parameters, does not work as of now */ + /* + sprintf(command, "%dS85=1.", pAxis->axisNo_); + status = transactController(pAxis->axisNo_, command, response); + */ + + /* actually enable */ + sprintf(command, "%dS04=1.0", pAxis->axisNo_); + status = transactController(pAxis->axisNo_, command, response); + } else { + sprintf(command, "%dS04=0.0", pAxis->axisNo_); + status = transactController(pAxis->axisNo_, command, response); + } + if (status == asynSuccess) { + pAxis->updateMsgTxtFromDriver(""); + } else { + errlogPrintf("Failure to enable or disable axis %d", + pAxis->axisNo_); + } + } + return asynMotorController::writeInt32(pasynUser, value); +} + +asynStatus + MasterMACSController::readInt32(asynUser * pasynUser, + epicsInt32 * value) +{ + + int function = pasynUser->reason; + MasterMACSAxis *pAxis = NULL; + char command[128] = { 0 }, reply[128] = { + 0}, *pPtr; + float fval; + int devStatus, isOn, comStatus; + + pAxis = (MasterMACSAxis *) (this->getAxis(pasynUser)); + if (!pAxis) { + return asynError; + } + if (function == axisEnabled_) { + // Read the overall status of this motor */ + sprintf(command, "%dR10", pAxis->axisNo_); + comStatus = transactController(pAxis->axisNo_, command, reply); + if (comStatus == asynError) { + return asynError; + } + pPtr = strstr(reply, "="); + sscanf(pPtr + 1, "%f", &fval); + devStatus = (int) fval; + isOn = pAxis->isOn(devStatus); + /* errlogPrintf("isOn in readInt32: %d, devStatus = %d\n", isOn, devStatus); */ + setIntegerParam(axisEnabled_, isOn); + *value = isOn; + callParamCallbacks(); + return asynSuccess; + } + return asynMotorController::readInt32(pasynUser, value); +} + + +// These are the MasterMACSAxis methods + +/** Creates a new MasterMACSAxis object. + * \param[in] pC Pointer to the MasterMACSController to which this axis belongs. + * \param[in] axisNo Index number of this axis, range 0 to pC->numAxes_-1. + * + * Initializes register numbers, etc. + */ +MasterMACSAxis::MasterMACSAxis(MasterMACSController * pC, int axisNo):SINQAxis(pC, axisNo), +pC_ +(pC) +{ + next_poll = -1; + hasStarted = false; + errorReported = 1; +} + +/** Reports on status of the axis + * \param[in] fp The file pointer on which report information will be written + * \param[in] level The level of report detail desired + * + * After printing device-specific information calls asynMotorAxis::report() + */ +void MasterMACSAxis::report(FILE * fp, int level) +{ + if (level > 0) { + fprintf(fp, " axis %d\n", axisNo_); + } +} + +int MasterMACSAxis::isOn(int axisStatus) +{ + if (CHECK_BIT(axisStatus, 0) && CHECK_BIT(axisStatus, 1)) { + return 1; + } + return 0; +} + +asynStatus + MasterMACSAxis::move(double position, int relative, double minVelocity, + double maxVelocity, double acceleration) +{ + asynStatus status; + char command[COMLEN], reply[COMLEN], *pPtr; + int devStatus; + float fval; + + errlogPrintf("minVelocity = %f, maxVelocity = %f\n", minVelocity, + maxVelocity); + memset(command, 0, COMLEN * sizeof(char)); + + /* clear motor error message */ + updateMsgTxtFromDriver(""); + + /* + * reset error code + */ + sprintf(command, "%dS17=0", axisNo_); + status = pC_->transactController(axisNo_, command, reply); + + /* + * test if the thing is On + */ + sprintf(command, "%dR10", axisNo_); + status = pC_->transactController(axisNo_, command, reply); + if (status == asynError) { + return asynError; + } + pPtr = strstr(reply, "="); + sscanf(pPtr + 1, "%f", &fval); + devStatus = (int) fval; + if (!isOn(devStatus)) { + setIntegerParam(pC_->motorStatusProblem_, true); + updateMsgTxtFromDriver("Motor disabled"); + errlogPrintf("ERROR: trying to start disabled axis %d\n", axisNo_); + return asynError; + } + + + /* + * set speed + */ + sprintf(command, "%dS05=%f", axisNo_, maxVelocity / 1000); + status = pC_->transactController(axisNo_, command, reply); + + if (relative) { + position += this->position; + } + errlogPrintf("Starting axis %d with destination %f", axisNo_, + position / 1000.); + + /* send target position */ + sprintf(command, "%dS02= %.3f", axisNo_, position / 1000.); + status = pC_->transactController(axisNo_, command, reply); + if (status == asynError) { + setIntegerParam(pC_->motorStatusProblem_, true); + return status; + } + + /* send move command */ + sprintf(command, "%dS00=1", axisNo_); + status = pC_->transactController(axisNo_, command, reply); + if (status == asynError) { + setIntegerParam(pC_->motorStatusProblem_, true); + return status; + } + hasStarted = true; + next_poll = -1; + homing = 0; + errorReported = 0; + + return status; +} + +asynStatus + MasterMACSAxis::home(double minVelocity, double maxVelocity, + double acceleration, int forwards) +{ + asynStatus status; + char command[COMLEN], reply[COMLEN], *pPtr; + int devStatus; + float fval; + + memset(command, 0, COMLEN * sizeof(char)); + + /* + * test if the thing is On + */ + sprintf(command, "%dR10", axisNo_); + status = pC_->transactController(axisNo_, command, reply); + if (status == asynError) { + return asynError; + } + pPtr = strstr(reply, "="); + sscanf(pPtr + 1, "%f", &fval); + devStatus = (int) fval; + if (!isOn(devStatus)) { + setIntegerParam(pC_->motorStatusProblem_, true); + updateMsgTxtFromDriver("Motor disabled"); + errlogPrintf("ERROR: trying to home disabled axis %d\n", axisNo_); + return asynError; + } + + setIntegerParam(pC_->motorStatusProblem_, false); + updateMsgTxtFromDriver(""); + errorReported = 0; + + + sprintf(command, "%dS00=9", axisNo_); + homing = 1; + next_poll = -1; + status = pC_->transactController(axisNo_, command, reply); + hasStarted = true; + return status; +} + +asynStatus + MasterMACSAxis::moveVelocity(double minVelocity, double maxVelocity, + double acceleration) +{ + setIntegerParam(pC_->motorStatusProblem_, true); + errlogSevPrintf(errlogMajor, + "This controller does not support the jog feature"); + return asynError; +} + +asynStatus MasterMACSAxis::stop(double acceleration) +{ + asynStatus status = asynSuccess; + char command[COMLEN], reply[COMLEN]; + + memset(command, 0, COMLEN * sizeof(char)); + + if (errorReported == 0) { + sprintf(command, "%dS00=8", axisNo_); + status = pC_->transactController(axisNo_, command, reply); + errlogPrintf("Sent STOP on Axis %d\n", axisNo_); + updateMsgTxtFromDriver("Axis interrupted"); + errorReported = 1; + } + return status; +} + +asynStatus MasterMACSAxis::setPosition(double position) +{ + setIntegerParam(pC_->motorStatusProblem_, true); + errlogSevPrintf(errlogMajor, + "This controller does not support setting position"); + updateMsgTxtFromDriver("Controller does not support setPosition"); + return asynError; +} + +asynStatus MasterMACSAxis::setClosedLoop(bool closedLoop) +{ + /* + This belongs into the Kingdom of Electronics. + We do not do this. + */ + + return asynError; +} + +/** Polls the axis. + * This function reads the motor position, the limit status, the home status, the moving status, + * and the drive power-on status. + * It calls setIntegerParam() and setDoubleParam() for each item that it polls, + * and then calls callParamCallbacks() at the end. + * \param[out] moving A flag that is set indicating that the axis is moving (true) or done (false). */ +asynStatus MasterMACSAxis::poll(bool * moving) +{ + asynStatus comStatus = asynSuccess; + char command[COMLEN], reply[COMLEN], *pPtr; + float errStatus, fval; + unsigned int errCode, derCode, devStatus; + + // protect against excessive polling + if (time(NULL) < next_poll) { + *moving = false; + return asynSuccess; + } + + setIntegerParam(pC_->motorStatusProblem_, false); + memset(command, 0, COMLEN * sizeof(char)); + + + + // Read the current motor position + sprintf(command, "%dR12", axisNo_); + comStatus = pC_->transactController(axisNo_, command, reply); + if (comStatus == asynError) { + setIntegerParam(pC_->motorStatusProblem_, true); + goto skip; + } + pPtr = strstr(reply, "="); + if (pPtr) { + sscanf(pPtr + 1, "%lf", &position); + } else { + errlogPrintf("Received malformed reply: Axis %d, reply %s\n", + axisNo_, reply + 4); + return asynError; + } + + setDoubleParam(pC_->motorPosition_, position * 1000.); + setDoubleParam(pC_->motorEncoderPosition_, position * 1000.); + + + // Read the overall status of this motor */ + sprintf(command, "%dR10", axisNo_); + comStatus = pC_->transactController(axisNo_, command, reply); + if (comStatus == asynError) { + setIntegerParam(pC_->motorStatusProblem_, true); + goto skip; + } + pPtr = strstr(reply, "="); + sscanf(pPtr + 1, "%f", &fval); + devStatus = (int) fval; + + errlogPrintf("Axis %d, position %lf, devStatus %d\n", axisNo_, + position, devStatus); + + if (!isOn(devStatus)) { + setIntegerParam(pC_->motorStatusProblem_, true); + updateMsgTxtFromDriver("Motor disabled"); + *moving = false; + setIntegerParam(pC_->motorStatusDone_, true); + goto skip; + } + + /* + * if the motor has never run, the status bit 10 is invalid + */ + if (!hasStarted) { + *moving = false; + setIntegerParam(pC_->motorStatusDone_, true); + next_poll = time(NULL) + IDLEPOLL; + goto skip; + } + + /* + * We may have a valid status bit... + */ + if (!CHECK_BIT(devStatus, 10)) { + /* we are still creeping along .... */ + *moving = true; + next_poll = -1; + setIntegerParam(pC_->motorStatusDone_, false); + goto skip; + } + + + /*we are done moving */ + *moving = false; + setIntegerParam(pC_->motorStatusDone_, true); + next_poll = time(NULL) + IDLEPOLL; + + /* when homing, set the proper flag */ + if (homing) { + setIntegerParam(pC_->motorStatusAtHome_, true); + } + + /* read error codes */ + sprintf(command, "%dR11", axisNo_); + comStatus = pC_->transactController(axisNo_, command, reply); + if (comStatus == asynError) { + setIntegerParam(pC_->motorStatusProblem_, true); + goto skip; + } + pPtr = strstr(reply, "="); + sscanf(pPtr + 1, "%f", &errStatus); + errCode = (unsigned int) errStatus; + + sprintf(command, "%dR18", axisNo_); + comStatus = pC_->transactController(axisNo_, command, reply); + if (comStatus == asynError) { + setIntegerParam(pC_->motorStatusProblem_, true); + goto skip; + } + pPtr = strstr(reply, "="); + sscanf(pPtr + 1, "%f", &errStatus); + derCode = (unsigned int) errStatus; + + errlogPrintf("Axis %d, errCode(R11) %d, derCode(R18) %d\n", axisNo_, + errCode, derCode); + + + setIntegerParam(pC_->motorStatusLowLimit_, false); + setIntegerParam(pC_->motorStatusHighLimit_, false); + + if (errCode == 0) { + /* There still may be errors in the status code */ + if (CHECK_BIT(devStatus, 3)) { + setIntegerParam(pC_->motorStatusProblem_, true); + errlogSevPrintf(errlogMajor, + "Fault bit in status code, but no error code on %d", + axisNo_); + updateMsgTxtFromDriver + ("Fault bit in status code without error code"); + } + if (CHECK_BIT(devStatus, 11)) { + setIntegerParam(pC_->motorStatusProblem_, true); + errlogSevPrintf(errlogMajor, + "Limit bit in status code, but no error code on %d", + axisNo_); + /* guessing which limit has been hit ... */ + if (position > 0) { + updateMsgTxtFromDriver("Hit positive limit switch"); + setIntegerParam(pC_->motorStatusHighLimit_, true); + setIntegerParam(pC_->motorStatusProblem_, false); + } else { + updateMsgTxtFromDriver("Hit negative limit switch"); + setIntegerParam(pC_->motorStatusLowLimit_, true); + setIntegerParam(pC_->motorStatusProblem_, false); + } + } + goto skip; + } + + /* + * from here on we are processing errors + */ + + setIntegerParam(pC_->motorStatusProblem_, true); + + if (CHECK_BIT(errCode, 0)) { + errlogSevPrintf(errlogMajor, "CAN error on %d", axisNo_); + updateMsgTxtFromDriver("CAN error"); + } else if (CHECK_BIT(errCode, 1)) { + errlogSevPrintf(errlogMajor, "Short circuit on %d", axisNo_); + updateMsgTxtFromDriver("Short circuit"); + } else if (CHECK_BIT(errCode, 2)) { + errlogSevPrintf(errlogMajor, "Invalide Setup on %d", axisNo_); + updateMsgTxtFromDriver("Invalid Setup"); + } else if (CHECK_BIT(errCode, 3)) { + errlogSevPrintf(errlogMajor, "Control error on %d", axisNo_); + updateMsgTxtFromDriver("Control error"); + } else if (CHECK_BIT(errCode, 4)) { + errlogSevPrintf(errlogMajor, "CAN communication error on %d", + axisNo_); + updateMsgTxtFromDriver("CAN communication error"); + } else if (CHECK_BIT(errCode, 5)) { + errlogSevPrintf(errlogMajor, "Feedback error on %d", axisNo_); + updateMsgTxtFromDriver("Feedback error"); + } else if (CHECK_BIT(errCode, 6)) { + updateMsgTxtFromDriver("Hit positive limit switch"); + setIntegerParam(pC_->motorStatusHighLimit_, true); + setIntegerParam(pC_->motorStatusProblem_, false); + } else if (CHECK_BIT(errCode, 7)) { + updateMsgTxtFromDriver("Hit negative limit switch"); + setIntegerParam(pC_->motorStatusLowLimit_, true); + setIntegerParam(pC_->motorStatusProblem_, false); + } else if (CHECK_BIT(errCode, 8)) { + errlogSevPrintf(errlogMajor, "Over current %d", axisNo_); + updateMsgTxtFromDriver("Over current"); + } else if (CHECK_BIT(errCode, 9)) { + errlogSevPrintf(errlogMajor, "I2T protection on %d", axisNo_); + updateMsgTxtFromDriver("I2t protection"); + } else if (CHECK_BIT(errCode, 10)) { + errlogSevPrintf(errlogMajor, "Over heated motor on %d", axisNo_); + updateMsgTxtFromDriver("Motor overheated"); + } else if (CHECK_BIT(errCode, 11)) { + errlogSevPrintf(errlogMajor, "Over temperature drive on %d", + axisNo_); + updateMsgTxtFromDriver("Over temperature drive"); + } else if (CHECK_BIT(errCode, 12)) { + errlogSevPrintf(errlogMajor, "Over voltage on %d", axisNo_); + updateMsgTxtFromDriver("Over voltage"); + } else if (CHECK_BIT(errCode, 13)) { + errlogSevPrintf(errlogMajor, "Under voltage on %d", axisNo_); + updateMsgTxtFromDriver("Under voltage"); + } else if (CHECK_BIT(errCode, 14)) { + errlogSevPrintf(errlogMajor, "Command error on %d", axisNo_); + updateMsgTxtFromDriver("Command error"); + } else if (CHECK_BIT(errCode, 15)) { + errlogSevPrintf(errlogMajor, "Motor disabled on %d", axisNo_); + updateMsgTxtFromDriver("Motor disabled"); + } + + skip: + callParamCallbacks(); + return comStatus; +} + +/** Code for iocsh registration */ +static const iocshArg + MasterMACSCreateControllerArg0 = { "Port name", iocshArgString }; + +static const iocshArg + MasterMACSCreateControllerArg1 = + { "MasterMACS port name", iocshArgString }; + +static const iocshArg + MasterMACSCreateControllerArg2 = { "Number of axes", iocshArgInt }; + +static const iocshArg *const + MasterMACSCreateControllerArgs[] = { &MasterMACSCreateControllerArg0, + &MasterMACSCreateControllerArg1, + &MasterMACSCreateControllerArg2 +}; + +static const iocshFuncDef + MasterMACSCreateControllerDef = + { "MasterMACSCreateController", 3, MasterMACSCreateControllerArgs }; +static void MasterMACSCreateContollerCallFunc(const iocshArgBuf * args) +{ + MasterMACSCreateController(args[0].sval, args[1].sval, args[2].ival); +} + +/** + * C wrapper for the MasterMACSAxis constructor. + * See MasterMAXSAxis::MasterMACSAxis. + * + */ +asynStatus MasterMACSCreateAxis(const char *MasterMACSPort, /* specify which controller by port name */ + int axis) +{ /* axis number (start from 1). */ + MasterMACSController *pC; + MasterMACSAxis *pAxis; + + static const char *functionName = "MasterMACSCreateAxis"; + + pC = (MasterMACSController *) findAsynPortDriver(MasterMACSPort); + if (!pC) { + printf("%s:%s: Error port %s not found\n", "MasterMACSDriver", + functionName, MasterMACSPort); + return asynError; + } + + pC->lock(); + pAxis = new MasterMACSAxis(pC, axis); + pAxis = NULL; + pC->unlock(); + return asynSuccess; +} + +/* MasterMACSCreateAxis */ +static const iocshArg + MasterMACSCreateAxisArg0 = { "Controller port name", iocshArgString }; + +static const iocshArg + MasterMACSCreateAxisArg1 = { "Axis number", iocshArgInt }; + +static const iocshArg *const + MasterMACSCreateAxisArgs[] = { &MasterMACSCreateAxisArg0, + &MasterMACSCreateAxisArg1 +}; + +static const iocshFuncDef + configMasterMACSAxis = + { "MasterMACSCreateAxis", 2, MasterMACSCreateAxisArgs }; + +static void configMasterMACSAxisCallFunc(const iocshArgBuf * args) +{ + MasterMACSCreateAxis(args[0].sval, args[1].ival); +} + +static void MasterMACSRegister(void) +{ + iocshRegister(&MasterMACSCreateControllerDef, + MasterMACSCreateContollerCallFunc); + iocshRegister(&configMasterMACSAxis, configMasterMACSAxisCallFunc); +} + +extern "C" { + epicsExportRegistrar(MasterMACSRegister); +} diff --git a/sinqEPICSApp/src/MasterMACSDriver.h b/sinqEPICSApp/src/MasterMACSDriver.h new file mode 100644 index 0000000..1a89477 --- /dev/null +++ b/sinqEPICSApp/src/MasterMACSDriver.h @@ -0,0 +1,71 @@ +/* + Driver for the MasterMACS motor controllers used at SINQ. + For documentation see the standard manuals area for SINQ or + Marcel Schildt. + + The MasterMACS has a special line protocol which is implemented in + drvAsynMMACSPort.c. The driver will not work with a standard asyn IPPort, + only with the special one. + + Mark Koennecke, March 2023 +*/ + +#include "SINQController.h" +#include "SINQAxis.h" + +#define COMLEN 50 + +class MasterMACSAxis : public SINQAxis +{ +public: + /* These are the methods we override from the base class */ + MasterMACSAxis(class MasterMACSController *pC, int axis); + void report(FILE *fp, int level); + asynStatus move(double position, int relative, double min_velocity, double max_velocity, double acceleration); + asynStatus moveVelocity(double min_velocity, double max_velocity, double acceleration); + asynStatus home(double min_velocity, double max_velocity, double acceleration, int forwards); + asynStatus stop(double acceleration); + asynStatus poll(bool *moving); + asynStatus setPosition(double position); + asynStatus setClosedLoop(bool closedLoop); + +private: + MasterMACSController *pC_; /**< Pointer to the asynMotorController to which this axis belongs. + * Abbreviated because it is used very frequently */ + double position; + int homing; + time_t next_poll; + int errorReported; + int hasStarted; /* The motor status is invalid if the thing has not run once */ + int isOn(int axisStatus); +friend class MasterMACSController; +}; + + +#define EnableAxisString "ENABLE_AXIS" +#define AxisEnabledString "AXIS_ENABLED" + +class MasterMACSController : public SINQController { +public: + MasterMACSController(const char *portName, const char *MasterMACSPortName, int numAxes); + + void report(FILE *fp, int level); + MasterMACSAxis* getAxis(asynUser *pasynUser); + MasterMACSAxis* getAxis(int axisNo); + + // overloaded because we want to enable/disable the motor + asynStatus writeInt32(asynUser *pasynUser, epicsInt32 value); + + // overloaded because we want to read the axis state + asynStatus readInt32(asynUser *pasynUser, epicsInt32 *value); + +friend class MasterMACSAxis; + private: + asynUser *pasynUserController_; + MasterMACSAxis **pAxes_; /**< Array of pointers to axis objects */ + + + asynStatus transactController(int axis, char command[COMLEN], char reply[COMLEN]); + int enableAxis_; + int axisEnabled_; +}; diff --git a/testmmac/db/asynRecord.db b/testmmac/db/asynRecord.db new file mode 100644 index 0000000..6c50e6d --- /dev/null +++ b/testmmac/db/asynRecord.db @@ -0,0 +1,9 @@ +record(asyn,"$(P)$(R)") +{ + field(DTYP,"asynRecordDevice") + field(PORT,"$(PORT)") + field(ADDR,"$(ADDR)") + field(OMAX,"$(OMAX)") + field(IMAX,"$(IMAX)") +} + diff --git a/testmmac/db/basic_asyn_motor.db b/testmmac/db/basic_asyn_motor.db new file mode 100644 index 0000000..fc19187 --- /dev/null +++ b/testmmac/db/basic_asyn_motor.db @@ -0,0 +1,23 @@ +record(motor,"$(P)$(M)") +{ + field(DESC,"$(DESC)") + field(DTYP,"$(DTYP)") + field(DIR,"$(DIR)") + field(VELO,"$(VELO)") + field(VBAS,"$(VBAS)") + field(ACCL,"$(ACCL)") + field(BDST,"$(BDST)") + field(BVEL,"$(BVEL)") + field(BACC,"$(BACC)") + field(OUT,"@asyn($(PORT),$(ADDR))") + field(MRES,"$(MRES)") + field(PREC,"$(PREC)") + field(EGU,"$(EGU)") + field(DHLM,"$(DHLM)") + field(DLLM,"$(DLLM)") + field(INIT,"$(INIT)") + field(TWV,"1") + field(RDBD,"$(RDBD)") + field(RTRY,"0") +} + diff --git a/testmmac/db/basic_motor.db b/testmmac/db/basic_motor.db new file mode 100644 index 0000000..98e55ec --- /dev/null +++ b/testmmac/db/basic_motor.db @@ -0,0 +1,21 @@ +grecord(motor,"$(P)$(M)") +{ + field(DESC,"$(DESC)") + field(DTYP,"$(DTYP)") + field(DIR,"$(DIR)") + field(VELO,"$(VELO)") + field(VBAS,"$(VBAS)") + field(ACCL,"$(ACCL)") + field(BDST,"$(BDST)") + field(BVEL,"$(BVEL)") + field(BACC,"$(BACC)") + field(OUT,"#C$(C) S$(S) @") + field(MRES,"$(MRES)") + field(PREC,"$(PREC)") + field(EGU,"$(EGU)") + field(DHLM,"$(DHLM)") + field(DLLM,"$(DLLM)") + field(INIT,"$(INIT)") + field(TWV,"1") +} + diff --git a/testmmac/db/motorMessage.db b/testmmac/db/motorMessage.db new file mode 100644 index 0000000..6168c2b --- /dev/null +++ b/testmmac/db/motorMessage.db @@ -0,0 +1,18 @@ + +# The message text +record(waveform, "$(P)$(M)-MsgTxt") { + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(N),1) MOTOR_MESSAGE_TEXT") + field(FTVL, "CHAR") + field(NELM, "80") + field(SCAN, "I/O Intr") +} + +record(ao,"$(P)m$(N)-Resolution"){ + field(DESC,"m$(N) Resolution") + field(DOL,"$(P)m$(N).MRES CP MS") + field(OMSL,"closed_loop") + field(DTYP,"asynFloat64") + field(OUT,"@asyn($(PORT),$(N))MOTOR_RESOLUTION") + field(PREC,"3") +} diff --git a/testmmac/db/pmacV3.db b/testmmac/db/pmacV3.db new file mode 100644 index 0000000..37c5b4f --- /dev/null +++ b/testmmac/db/pmacV3.db @@ -0,0 +1,14 @@ +# enable axis +record(longout, "$(P)$(M):Enable") { + field(DTYP, "asynInt32") + field(OUT, "@asyn($(PORT),$(N),1) ENABLE_AXIS") + field(PINI, "YES") +} + +# enable axis +record(longin, "$(P)$(M):Enable_RBV") { + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(N),1) AXIS_ENABLED") + field(PINI, "YES") + field(SCAN, "1 second") +} diff --git a/testmmac/db/sinq_asyn_motor.db b/testmmac/db/sinq_asyn_motor.db new file mode 100644 index 0000000..4d818ad --- /dev/null +++ b/testmmac/db/sinq_asyn_motor.db @@ -0,0 +1,47 @@ +record(motor,"$(P)$(M)") +{ + field(DESC,"$(DESC)") + field(DTYP,"$(DTYP)") + field(DIR,"$(DIR)") + field(VELO,"$(VELO)") + field(VBAS,"$(VBAS)") + field(ACCL,"$(ACCL)") + field(BDST,"$(BDST)") + field(BVEL,"$(BVEL)") + field(BACC,"$(BACC)") + field(OUT,"@asyn($(PORT),$(ADDR))") + field(MRES,"$(MRES)") + field(PREC,"$(PREC)") + field(EGU,"$(EGU)") + field(DHLM,"$(DHLM)") + field(DLLM,"$(DLLM)") + field(INIT,"$(INIT)") + field(TWV,"1") + field(RDBD,"$(RDBD)") +} + + +# The message text +record(waveform, "$(P)$(M)-MsgTxt") { + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(N),1) MOTOR_MESSAGE_TEXT") + field(FTVL, "CHAR") + field(NELM, "80") + field(SCAN, "I/O Intr") +} + +# enable axis +record(longout, "$(P)$(M):Enable") { + field(DTYP, "asynInt32") + field(OUT, "@asyn($(PORT),$(N),1) ENABLE_AXIS") + field(PINI, "YES") +} + +# enable axis +record(longin, "$(P)$(M):Enable_RBV") { + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(N),1) AXIS_ENABLED") + field(PINI, "YES") + field(SCAN, "5 second") +} + diff --git a/testmmac/mmacs.sub b/testmmac/mmacs.sub new file mode 100644 index 0000000..02a1254 --- /dev/null +++ b/testmmac/mmacs.sub @@ -0,0 +1,15 @@ +file "$(TOP)/db/basic_asyn_motor.db" +{ +pattern +{P, N, M, DTYP, PORT, ADDR, DESC, EGU, DIR, VELO, VBAS, ACCL, BDST, BVEL, BACC, MRES, PREC, DLLM, DHLM, INIT} +{KM36:mota:, 5, "m$(N)", "asynMotor", mota, 5, "m5", degree, Pos, 2.0, 0.1, .2, 0, 1, .2, 1., 3, -20.0, 20.0, ""} +{KM36:mota:, 6, "m$(N)", "asynMotor", mota, 6, "m6", degree, Pos, 2.0, 0.1, .2, 0, 1, .2, 1., 3, -20.0, 20.0, ""} +} + +file "$(TOP)/db/motorMessage.db" +{ +pattern +{P,N, M,PORT} +{KM36:mota:, 5, "m$(N)",mota} +{KM36:mota:, 6, "m$(N)",mota} +} diff --git a/testmmac/mmacs2.sub b/testmmac/mmacs2.sub new file mode 100644 index 0000000..05c4dc9 --- /dev/null +++ b/testmmac/mmacs2.sub @@ -0,0 +1,8 @@ +file "$(TOP)/db/sinq_asyn_motor.db" +{ +pattern +{P, N, M, DTYP, PORT, ADDR, DESC, EGU, DIR, VELO, VBAS, ACCL, BDST, BVEL, BACC, MRES, PREC, DLLM, DHLM, RDBD, INIT} +{KM36:mota:,5,"m$(N)","asynMotor", mota, 5, "m5", degree, Pos, 2.0, 0.1, .2, 0, 1, .2, .001, 3,-400000.000,400000.000,.01, ""} +{KM36:mota:,6,"m$(N)","asynMotor", mota, 6, "m6", degree, Pos, 2.0, 0.1, .2, 0, 1, .2, .001, 3,-200000.000,200000.000,.01, ""} +} + diff --git a/testmmac/mota.sub b/testmmac/mota.sub new file mode 100644 index 0000000..7a5e23b --- /dev/null +++ b/testmmac/mota.sub @@ -0,0 +1,13 @@ +file "$(TOP)/db/basic_asyn_motor.db" +{ +pattern +{P, N, M, DTYP, PORT, ADDR, DESC, EGU, DIR, VELO, VBAS, ACCL, BDST, BVEL, BACC, MRES, PREC, DLLM, DHLM, INIT} +{KM36:mota:, 2, "m$(N)", "asynMotor", mota, 2, "sgl", degree, Pos, 2.0, 0.1, .2, 0, 1, .2, 1., 3, -20.0, 20.0, ""} +} + +file "$(TOP)/db/motorMessage.db" +{ +pattern +{P,N, M,PORT} +{KM36:mota:, 2, "m$(N)",mota} +} diff --git a/testmmac/motaspeed.sub b/testmmac/motaspeed.sub new file mode 100644 index 0000000..dacfebb --- /dev/null +++ b/testmmac/motaspeed.sub @@ -0,0 +1,12 @@ +file "$(TOP)/db/sinq_asyn_motor.db" +{ +pattern +{P, N, M, DTYP, PORT, ADDR, DESC, EGU, DIR, VELO, VBAS, ACCL, BDST, BVEL, BACC, MRES, PREC, DLLM, DHLM, INIT, RDBD} +{KM36:mota:,2,"m$(N)","asynMotor", mota, 2, "sgl", degree, Pos, 100, 0.1, .2, 0, 1, .2, 1., 3,-180.0,360.0,"", 0.2}} + +file "$(TOP)/db/motorMessage.db" +{ +pattern +{P,N, M,PORT} +{KM36:mota:, 2, "m$(N)",mota} +} diff --git a/testmmac/testmmacs.cmd b/testmmac/testmmacs.cmd new file mode 100755 index 0000000..19c0833 --- /dev/null +++ b/testmmac/testmmacs.cmd @@ -0,0 +1,19 @@ +#!/usr/local/bin/iocsh + +require sinq,koennecke + +epicsEnvSet("TOP","/afs/psi.ch/project/sinqdev/sinqepicsapp/testmmac") + +#drvAsynMMACSPortConfigure("macs1", "localhost:8080",0,0,0) +#asynInterposeEosConfig("macs1", 0, 0, 0) +#dbLoadRecords("$(TOP)/db/asynRecord.db","P=KM36:,R=macs1,PORT=macs1,ADDR=0,OMAX=80,IMAX=80") +#asynSetTraceMask("macs1", 0, 255) + +drvAsynIPPortConfigure("macs1", "localhost:8080",0,0,0) +#asynSetTraceMask("macs1", 0, 255) +MasterMACSCreateController("mota","macs1",7) +MasterMACSCreateAxis("mota",5) +MasterMACSCreateAxis("mota",6) + +dbLoadTemplate "mmacs2.sub" + diff --git a/testpmacV3/db/asynRecord.db b/testpmacV3/db/asynRecord.db new file mode 100644 index 0000000..6c50e6d --- /dev/null +++ b/testpmacV3/db/asynRecord.db @@ -0,0 +1,9 @@ +record(asyn,"$(P)$(R)") +{ + field(DTYP,"asynRecordDevice") + field(PORT,"$(PORT)") + field(ADDR,"$(ADDR)") + field(OMAX,"$(OMAX)") + field(IMAX,"$(IMAX)") +} + diff --git a/testpmacV3/db/basic_asyn_motor.db b/testpmacV3/db/basic_asyn_motor.db new file mode 100644 index 0000000..92c02ca --- /dev/null +++ b/testpmacV3/db/basic_asyn_motor.db @@ -0,0 +1,22 @@ +record(motor,"$(P)$(M)") +{ + field(DESC,"$(DESC)") + field(DTYP,"$(DTYP)") + field(DIR,"$(DIR)") + field(VELO,"$(VELO)") + field(VBAS,"$(VBAS)") + field(ACCL,"$(ACCL)") + field(BDST,"$(BDST)") + field(BVEL,"$(BVEL)") + field(BACC,"$(BACC)") + field(OUT,"@asyn($(PORT),$(ADDR))") + field(MRES,"$(MRES)") + field(PREC,"$(PREC)") + field(EGU,"$(EGU)") + field(DHLM,"$(DHLM)") + field(DLLM,"$(DLLM)") + field(INIT,"$(INIT)") + field(TWV,"1") + field(RTRY,"0") +} + diff --git a/testpmacV3/db/huber.dbd b/testpmacV3/db/huber.dbd new file mode 100644 index 0000000..6dcf56f --- /dev/null +++ b/testpmacV3/db/huber.dbd @@ -0,0 +1,19544 @@ +menu(menuYesNo) { + choice(menuYesNoNO, "NO") + choice(menuYesNoYES, "YES") +} +menu(serialFCTL) { + choice(serialFCTL_unknown, "Unknown") + choice(serialFCTL_None, "None") + choice(serialFCTL_Hardware, "Hardware") +} +menu(menuOmsl) { + choice(menuOmslsupervisory, "supervisory") + choice(menuOmslclosed_loop, "closed_loop") +} +menu(ipDRTO) { + choice(ipDRTO_unknown, "Unknown") + choice(ipDRTO_No, "No") + choice(ipDRTO_Yes, "Yes") +} +menu(menuFtype) { + choice(menuFtypeSTRING, "STRING") + choice(menuFtypeCHAR, "CHAR") + choice(menuFtypeUCHAR, "UCHAR") + choice(menuFtypeSHORT, "SHORT") + choice(menuFtypeUSHORT, "USHORT") + choice(menuFtypeLONG, "LONG") + choice(menuFtypeULONG, "ULONG") + choice(menuFtypeINT64, "INT64") + choice(menuFtypeUINT64, "UINT64") + choice(menuFtypeFLOAT, "FLOAT") + choice(menuFtypeDOUBLE, "DOUBLE") + choice(menuFtypeENUM, "ENUM") +} +menu(selSELM) { + choice(selSELM_Specified, "Specified") + choice(selSELM_High_Signal, "High Signal") + choice(selSELM_Low_Signal, "Low Signal") + choice(selSELM_Median_Signal, "Median Signal") +} +menu(asynENABLE) { + choice(asynENABLE_Disable, "Disable") + choice(asynENABLE_Enable, "Enable") +} +menu(compressALG) { + choice(compressALG_N_to_1_Low_Value, "N to 1 Low Value") + choice(compressALG_N_to_1_High_Value, "N to 1 High Value") + choice(compressALG_N_to_1_Average, "N to 1 Average") + choice(compressALG_Average, "Average") + choice(compressALG_Circular_Buffer, "Circular Buffer") + choice(compressALG_N_to_1_Median, "N to 1 Median") +} +menu(motorFOFF) { + choice(motorFOFF_Variable, "Variable") + choice(motorFOFF_Frozen, "Frozen") +} +menu(asynTRACE) { + choice(asynTRACE_Off, "Off") + choice(asynTRACE_On, "On") +} +menu(bufferingALG) { + choice(bufferingALG_FIFO, "FIFO Buffer") + choice(bufferingALG_LIFO, "LIFO Buffer") +} +menu(motorDIR) { + choice(motorDIR_Pos, "Pos") + choice(motorDIR_Neg, "Neg") +} +menu(menuPost) { + choice(menuPost_OnChange, "On Change") + choice(menuPost_Always, "Always") +} +menu(stringoutPOST) { + choice(stringoutPOST_OnChange, "On Change") + choice(stringoutPOST_Always, "Always") +} +menu(menuSimm) { + choice(menuSimmNO, "NO") + choice(menuSimmYES, "YES") + choice(menuSimmRAW, "RAW") +} +menu(serialPRTY) { + choice(serialPRTY_unknown, "Unknown") + choice(serialPRTY_None, "None") + choice(serialPRTY_Even, "Even") + choice(serialPRTY_Odd, "Odd") +} +menu(menuPriority) { + choice(menuPriorityLOW, "LOW") + choice(menuPriorityMEDIUM, "MEDIUM") + choice(menuPriorityHIGH, "HIGH") +} +menu(asynINTERFACE) { + choice(asynINTERFACE_OCTET, "asynOctet") + choice(asynINTERFACE_INT32, "asynInt32") + choice(asynINTERFACE_UINT32, "asynUInt32Digital") + choice(asynINTERFACE_FLOAT64, "asynFloat64") +} +menu(aoOIF) { + choice(aoOIF_Full, "Full") + choice(aoOIF_Incremental, "Incremental") +} +menu(asynCONNECT) { + choice(asynCONNECT_Disconnect, "Disconnect") + choice(asynCONNECT_Connect, "Connect") +} +menu(motorTORQ) { + choice(motorTORQ_Disable, "Disable") + choice(motorTORQ_Enable, "Enable") +} +menu(asynAUTOCONNECT) { + choice(asynAUTOCONNECT_noAutoConnect, "noAutoConnect") + choice(asynAUTOCONNECT_autoConnect, "autoConnect") +} +menu(stringinPOST) { + choice(stringinPOST_OnChange, "On Change") + choice(stringinPOST_Always, "Always") +} +menu(menuAlarmStat) { + choice(menuAlarmStatNO_ALARM, "NO_ALARM") + choice(menuAlarmStatREAD, "READ") + choice(menuAlarmStatWRITE, "WRITE") + choice(menuAlarmStatHIHI, "HIHI") + choice(menuAlarmStatHIGH, "HIGH") + choice(menuAlarmStatLOLO, "LOLO") + choice(menuAlarmStatLOW, "LOW") + choice(menuAlarmStatSTATE, "STATE") + choice(menuAlarmStatCOS, "COS") + choice(menuAlarmStatCOMM, "COMM") + choice(menuAlarmStatTIMEOUT, "TIMEOUT") + choice(menuAlarmStatHWLIMIT, "HWLIMIT") + choice(menuAlarmStatCALC, "CALC") + choice(menuAlarmStatSCAN, "SCAN") + choice(menuAlarmStatLINK, "LINK") + choice(menuAlarmStatSOFT, "SOFT") + choice(menuAlarmStatBAD_SUB, "BAD_SUB") + choice(menuAlarmStatUDF, "UDF") + choice(menuAlarmStatDISABLE, "DISABLE") + choice(menuAlarmStatSIMM, "SIMM") + choice(menuAlarmStatREAD_ACCESS, "READ_ACCESS") + choice(menuAlarmStatWRITE_ACCESS, "WRITE_ACCESS") +} +menu(motorSTUP) { + choice(motorSTUP_OFF, "OFF") + choice(motorSTUP_ON, "ON") + choice(motorSTUP_BUSY, "BUSY") +} +menu(fanoutSELM) { + choice(fanoutSELM_All, "All") + choice(fanoutSELM_Specified, "Specified") + choice(fanoutSELM_Mask, "Mask") +} +menu(waveformPOST) { + choice(waveformPOST_Always, "Always") + choice(waveformPOST_OnChange, "On Change") +} +menu(histogramCMD) { + choice(histogramCMD_Read, "Read") + choice(histogramCMD_Clear, "Clear") + choice(histogramCMD_Start, "Start") + choice(histogramCMD_Stop, "Stop") +} +menu(serialMCTL) { + choice(serialMCTL_unknown, "Unknown") + choice(serialMCTL_CLOCAL, "CLOCAL") + choice(serialMCTL_Yes, "YES") +} +menu(serialBAUD) { + choice(serialBAUD_unknown, "Unknown") + choice(serialBAUD_300, "300") + choice(serialBAUD_600, "600") + choice(serialBAUD_1200, "1200") + choice(serialBAUD_2400, "2400") + choice(serialBAUD_4800, "4800") + choice(serialBAUD_9600, "9600") + choice(serialBAUD_19200, "19200") + choice(serialBAUD_38400, "38400") + choice(serialBAUD_57600, "57600") + choice(serialBAUD_115200, "115200") + choice(serialBAUD_230400, "230400") + choice(serialBAUD_460800, "460800") + choice(serialBAUD_576000, "576000") + choice(serialBAUD_921600, "921600") + choice(serialBAUD_1152000, "1152000") +} +menu(gpibUCMD) { + choice(gpibUCMD_None, "None") + choice(gpibUCMD_Device_Clear__DCL_, "Device Clear (DCL)") + choice(gpibUCMD_Local_Lockout__LL0_, "Local Lockout (LL0)") + choice(gpibUCMD_Serial_Poll_Disable__SPD_, "Serial Poll Disable (SPD)") + choice(gpibUCMD_Serial_Poll_Enable__SPE_, "Serial Poll Enable (SPE)") + choice(gpibUCMD_Unlisten__UNL_, "Unlisten (UNL)") + choice(gpibUCMD_Untalk__UNT_, "Untalk (UNT)") +} +menu(aaoPOST) { + choice(aaoPOST_Always, "Always") + choice(aaoPOST_OnChange, "On Change") +} +menu(motorMODE) { + choice(motorMODE_Position, "Position") + choice(motorMODE_Velocity, "Velocity") +} +menu(menuIvoa) { + choice(menuIvoaContinue_normally, "Continue normally") + choice(menuIvoaDon_t_drive_outputs, "Don't drive outputs") + choice(menuIvoaSet_output_to_IVOV, "Set output to IVOV") +} +menu(menuAlarmSevr) { + choice(menuAlarmSevrNO_ALARM, "NO_ALARM") + choice(menuAlarmSevrMINOR, "MINOR") + choice(menuAlarmSevrMAJOR, "MAJOR") + choice(menuAlarmSevrINVALID, "INVALID") +} +menu(aaiPOST) { + choice(aaiPOST_Always, "Always") + choice(aaiPOST_OnChange, "On Change") +} +menu(seqSELM) { + choice(seqSELM_All, "All") + choice(seqSELM_Specified, "Specified") + choice(seqSELM_Mask, "Mask") +} +menu(motorSPMG) { + choice(motorSPMG_Stop, "Stop") + choice(motorSPMG_Pause, "Pause") + choice(motorSPMG_Move, "Move") + choice(motorSPMG_Go, "Go") +} +menu(dfanoutSELM) { + choice(dfanoutSELM_All, "All") + choice(dfanoutSELM_Specified, "Specified") + choice(dfanoutSELM_Mask, "Mask") +} +menu(serialSBIT) { + choice(serialSBIT_unknown, "Unknown") + choice(serialSBIT_1, "1") + choice(serialSBIT_2, "2") +} +menu(calcoutINAV) { + choice(calcoutINAV_EXT_NC, "Ext PV NC") + choice(calcoutINAV_EXT, "Ext PV OK") + choice(calcoutINAV_LOC, "Local PV") + choice(calcoutINAV_CON, "Constant") +} +menu(menuScan) { + choice(menuScanPassive, "Passive") + choice(menuScanEvent, "Event") + choice(menuScanI_O_Intr, "I/O Intr") + choice(menuScan10_second, "10 second") + choice(menuScan5_second, "5 second") + choice(menuScan2_second, "2 second") + choice(menuScan1_second, "1 second") + choice(menuScan_5_second, ".5 second") + choice(menuScan_2_second, ".2 second") + choice(menuScan_1_second, ".1 second") +} +menu(menuPini) { + choice(menuPiniNO, "NO") + choice(menuPiniYES, "YES") + choice(menuPiniRUN, "RUN") + choice(menuPiniRUNNING, "RUNNING") + choice(menuPiniPAUSE, "PAUSE") + choice(menuPiniPAUSED, "PAUSED") +} +menu(aSubLFLG) { + choice(aSubLFLG_IGNORE, "IGNORE") + choice(aSubLFLG_READ, "READ") +} +menu(motorRMOD) { + choice(motorRMOD_D, "Default") + choice(motorRMOD_A, "Arithmetic") + choice(motorRMOD_G, "Geometric") + choice(motorRMOD_I, "In-Position") +} +menu(asynFMT) { + choice(asynFMT_ASCII, "ASCII") + choice(asynFMT_Hybrid, "Hybrid") + choice(asynFMT_Binary, "Binary") +} +menu(menuConvert) { + choice(menuConvertNO_CONVERSION, "NO CONVERSION") + choice(menuConvertSLOPE, "SLOPE") + choice(menuConvertLINEAR, "LINEAR") + choice(menuConverttypeKdegF, "typeKdegF") + choice(menuConverttypeKdegC, "typeKdegC") + choice(menuConverttypeJdegF, "typeJdegF") + choice(menuConverttypeJdegC, "typeJdegC") + choice(menuConverttypeEdegF, "typeEdegF(ixe only)") + choice(menuConverttypeEdegC, "typeEdegC(ixe only)") + choice(menuConverttypeTdegF, "typeTdegF") + choice(menuConverttypeTdegC, "typeTdegC") + choice(menuConverttypeRdegF, "typeRdegF") + choice(menuConverttypeRdegC, "typeRdegC") + choice(menuConverttypeSdegF, "typeSdegF") + choice(menuConverttypeSdegC, "typeSdegC") +} +menu(aSubEFLG) { + choice(aSubEFLG_NEVER, "NEVER") + choice(aSubEFLG_ON_CHANGE, "ON CHANGE") + choice(aSubEFLG_ALWAYS, "ALWAYS") +} +menu(serialDBIT) { + choice(serialDBIT_unknown, "Unknown") + choice(serialDBIT_5, "5") + choice(serialDBIT_6, "6") + choice(serialDBIT_7, "7") + choice(serialDBIT_8, "8") +} +menu(asynTMOD) { + choice(asynTMOD_Write_Read, "Write/Read") + choice(asynTMOD_Write, "Write") + choice(asynTMOD_Read, "Read") + choice(asynTMOD_Flush, "Flush") + choice(asynTMOD_NoIO, "NoI/O") +} +menu(gpibACMD) { + choice(gpibACMD_None, "None") + choice(gpibACMD_Group_Execute_Trig___GET_, "Group Execute Trig. (GET)") + choice(gpibACMD_Go_To_Local__GTL_, "Go To Local (GTL)") + choice(gpibACMD_Selected_Dev__Clear__SDC_, "Selected Dev. Clear (SDC)") + choice(gpibACMD_Take_Control__TCT_, "Take Control (TCT)") + choice(gpibACMD_Serial_Poll, "Serial Poll") +} +menu(calcoutDOPT) { + choice(calcoutDOPT_Use_VAL, "Use CALC") + choice(calcoutDOPT_Use_OVAL, "Use OCAL") +} +menu(serialIX) { + choice(serialIX_unknown, "Unknown") + choice(serialIX_No, "No") + choice(serialIX_Yes, "Yes") +} +menu(asynEOMREASON) { + choice(asynEOMREASONNone, "None") + choice(asynEOMREASONCNT, "Count") + choice(asynEOMREASONEOS, "Eos") + choice(asynEOMREASONCNTEOS, "Count Eos") + choice(asynEOMREASONEND, "End") + choice(asynEOMREASONCNTEND, "Count End") + choice(asynEOMREASONEOSEND, "Eos End") + choice(asynEOMREASONCNTEOSEND, "Count Eos End") +} +menu(motorSET) { + choice(motorSET_Use, "Use") + choice(motorSET_Set, "Set") +} +menu(motorUEIP) { + choice(motorUEIP_No, "No") + choice(motorUEIP_Yes, "Yes") +} +menu(calcoutOOPT) { + choice(calcoutOOPT_Every_Time, "Every Time") + choice(calcoutOOPT_On_Change, "On Change") + choice(calcoutOOPT_When_Zero, "When Zero") + choice(calcoutOOPT_When_Non_zero, "When Non-zero") + choice(calcoutOOPT_Transition_To_Zero, "Transition To Zero") + choice(calcoutOOPT_Transition_To_Non_zero, "Transition To Non-zero") +} +recordtype(ao) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + size(29) + special(SPC_AS) + promptgroup("10 - Common") + prompt("Access Security Group") + } + field(SCAN, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scan Mechanism") + interest(1) + special(SPC_SCAN) + menu(menuScan) + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + size(40) + special(SPC_SCAN) + interest(1) + prompt("Event Name") + promptgroup("20 - Scan") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Link") + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + prompt("Force Processing") + pp(TRUE) + } + field(STAT, DBF_MENU) { + initial("UDF") + prompt("Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(NSEV, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKT, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuYesNo) + promptgroup("70 - Alarm") + initial("YES") + prompt("Alarm Ack Transient") + } + field(DISS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + interest(1) + special(SPC_NOMOD) + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + interest(4) + special(SPC_NOMOD) + } + field(SPVT, DBF_NOACCESS) { + prompt("Scan Private") + extra("struct scan_element *spvt") + interest(4) + special(SPC_NOMOD) + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of RSET") + extra("struct typed_rset *rset") + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct dset *dset") + prompt("DSET address") + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + special(SPC_NOMOD) + interest(4) + } + field(LSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + interest(1) + menu(menuPriority) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scheduling Priority") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + prompt("Break Point") + extra("char bkpt") + } + field(UDF, DBF_UCHAR) { + interest(1) + initial("1") + pp(TRUE) + prompt("Undefined") + promptgroup("10 - Common") + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + extra("epicsTimeStamp time") + prompt("Time") + interest(2) + special(SPC_NOMOD) + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_DOUBLE) { + promptgroup("50 - Output") + pp(TRUE) + prompt("Desired Output") + asl(ASL0) + } + field(OVAL, DBF_DOUBLE) { + prompt("Output Value") + } + field(OUT, DBF_OUTLINK) { + prompt("Output Specification") + promptgroup("50 - Output") + interest(1) + } + field(OROC, DBF_DOUBLE) { + interest(1) + prompt("Output Rate of Change") + promptgroup("50 - Output") + } + field(DOL, DBF_INLINK) { + prompt("Desired Output Loc") + promptgroup("40 - Input") + interest(1) + } + field(OMSL, DBF_MENU) { + promptgroup("50 - Output") + prompt("Output Mode Select") + interest(1) + menu(menuOmsl) + } + field(OIF, DBF_MENU) { + menu(aoOIF) + interest(1) + prompt("Out Full/Incremental") + promptgroup("50 - Output") + } + field(PREC, DBF_SHORT) { + prompt("Display Precision") + promptgroup("80 - Display") + prop(YES) + interest(1) + } + field(LINR, DBF_MENU) { + pp(TRUE) + prompt("Linearization") + interest(1) + promptgroup("60 - Convert") + menu(menuConvert) + special(SPC_LINCONV) + } + field(EGUF, DBF_DOUBLE) { + special(SPC_LINCONV) + interest(1) + prompt("Eng Units Full") + pp(TRUE) + promptgroup("60 - Convert") + } + field(EGUL, DBF_DOUBLE) { + special(SPC_LINCONV) + interest(1) + pp(TRUE) + prompt("Eng Units Low") + promptgroup("60 - Convert") + } + field(EGU, DBF_STRING) { + interest(1) + size(16) + prop(YES) + promptgroup("80 - Display") + prompt("Engineering Units") + } + field(ROFF, DBF_ULONG) { + interest(2) + pp(TRUE) + prompt("Raw Offset") + } + field(EOFF, DBF_DOUBLE) { + interest(2) + promptgroup("60 - Convert") + prompt("EGU to Raw Offset") + pp(TRUE) + } + field(ESLO, DBF_DOUBLE) { + initial("1") + pp(TRUE) + prompt("EGU to Raw Slope") + promptgroup("60 - Convert") + interest(2) + } + field(DRVH, DBF_DOUBLE) { + interest(1) + prompt("Drive High Limit") + pp(TRUE) + prop(YES) + promptgroup("30 - Action") + } + field(DRVL, DBF_DOUBLE) { + interest(1) + promptgroup("30 - Action") + prop(YES) + pp(TRUE) + prompt("Drive Low Limit") + } + field(HOPR, DBF_DOUBLE) { + promptgroup("80 - Display") + prop(YES) + prompt("High Operating Range") + interest(1) + } + field(LOPR, DBF_DOUBLE) { + prop(YES) + promptgroup("80 - Display") + prompt("Low Operating Range") + interest(1) + } + field(AOFF, DBF_DOUBLE) { + promptgroup("60 - Convert") + pp(TRUE) + prompt("Adjustment Offset") + interest(1) + } + field(ASLO, DBF_DOUBLE) { + interest(1) + promptgroup("60 - Convert") + pp(TRUE) + prompt("Adjustment Slope") + } + field(HIHI, DBF_DOUBLE) { + interest(1) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Hihi Alarm Limit") + } + field(LOLO, DBF_DOUBLE) { + prompt("Lolo Alarm Limit") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + interest(1) + } + field(HIGH, DBF_DOUBLE) { + interest(1) + pp(TRUE) + prompt("High Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + } + field(LOW, DBF_DOUBLE) { + interest(1) + prop(YES) + promptgroup("70 - Alarm") + prompt("Low Alarm Limit") + pp(TRUE) + } + field(HHSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + prop(YES) + promptgroup("70 - Alarm") + prompt("Hihi Severity") + pp(TRUE) + } + field(LLSV, DBF_MENU) { + prop(YES) + promptgroup("70 - Alarm") + prompt("Lolo Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(HSV, DBF_MENU) { + pp(TRUE) + prompt("High Severity") + promptgroup("70 - Alarm") + prop(YES) + menu(menuAlarmSevr) + interest(1) + } + field(LSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("Low Severity") + promptgroup("70 - Alarm") + prop(YES) + } + field(HYST, DBF_DOUBLE) { + interest(1) + prompt("Alarm Deadband") + promptgroup("70 - Alarm") + } + field(ADEL, DBF_DOUBLE) { + interest(1) + promptgroup("80 - Display") + prompt("Archive Deadband") + } + field(MDEL, DBF_DOUBLE) { + prompt("Monitor Deadband") + promptgroup("80 - Display") + interest(1) + } + field(RVAL, DBF_LONG) { + prompt("Current Raw Value") + pp(TRUE) + } + field(ORAW, DBF_LONG) { + prompt("Previous Raw Value") + special(SPC_NOMOD) + interest(3) + } + field(RBV, DBF_LONG) { + special(SPC_NOMOD) + prompt("Readback Value") + } + field(ORBV, DBF_LONG) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Readback Value") + } + field(PVAL, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Previous value") + } + field(LALM, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Last Value Alarmed") + } + field(ALST, DBF_DOUBLE) { + prompt("Last Value Archived") + interest(3) + special(SPC_NOMOD) + } + field(MLST, DBF_DOUBLE) { + prompt("Last Val Monitored") + special(SPC_NOMOD) + interest(3) + } + field(PBRK, DBF_NOACCESS) { + prompt("Ptrto brkTable") + extra("void * pbrk") + special(SPC_NOMOD) + interest(4) + } + field(INIT, DBF_SHORT) { + prompt("Initialized?") + interest(3) + special(SPC_NOMOD) + } + field(LBRK, DBF_SHORT) { + interest(3) + special(SPC_NOMOD) + prompt("LastBreak Point") + } + field(SIOL, DBF_OUTLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Output Link") + interest(1) + } + field(SIML, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + interest(1) + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + special(SPC_MOD) + menu(menuYesNo) + interest(1) + } + field(SIMS, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + promptgroup("90 - Simulate") + prompt("Simulation Mode Severity") + } + field(OLDSIMM, DBF_MENU) { + prompt("Prev. Simulation Mode") + menu(menuSimm) + special(SPC_NOMOD) + interest(4) + } + field(SSCN, DBF_MENU) { + promptgroup("90 - Simulate") + prompt("Sim. Mode Scan") + initial("65535") + interest(1) + menu(menuScan) + } + field(SDLY, DBF_DOUBLE) { + initial("-1.0") + prompt("Sim. Mode Async Delay") + promptgroup("90 - Simulate") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + } + field(IVOA, DBF_MENU) { + interest(2) + menu(menuIvoa) + promptgroup("50 - Output") + prompt("INVALID output action") + } + field(IVOV, DBF_DOUBLE) { + interest(2) + promptgroup("50 - Output") + prompt("INVALID output value") + } + field(OMOD, DBF_UCHAR) { + special(SPC_NOMOD) + prompt("Was OVAL modified?") + } +} +device(ao, CONSTANT, devAoSoft, "Soft Channel") +device(ao, CONSTANT, devAoSoftRaw, "Raw Soft Channel") +device(ao, CONSTANT, devAoSoftCallback, "Async Soft Channel") +device(ao, INST_IO, asynAoInt32, "asynInt32") +device(ao, INST_IO, asynAoFloat64, "asynFloat64") +recordtype(motor) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + special(SPC_AS) + size(29) + } + field(SCAN, DBF_MENU) { + interest(1) + menu(menuScan) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + interest(1) + menu(menuPini) + promptgroup("20 - Scan") + prompt("Process at iocInit") + } + field(PHAS, DBF_SHORT) { + special(SPC_SCAN) + interest(1) + prompt("Scan Phase") + promptgroup("20 - Scan") + } + field(EVNT, DBF_STRING) { + size(40) + special(SPC_SCAN) + interest(1) + prompt("Event Name") + promptgroup("20 - Scan") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + interest(1) + prompt("Time Stamp Link") + promptgroup("20 - Scan") + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + special(SPC_NOMOD) + interest(4) + } + field(MLIS, DBF_NOACCESS) { + extra("ELLLIST mlis") + prompt("Monitor List") + interest(4) + special(SPC_NOMOD) + } + field(BKLNK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + pp(TRUE) + prompt("Force Processing") + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + prompt("Alarm Status") + initial("UDF") + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKT, DBF_MENU) { + promptgroup("70 - Alarm") + initial("YES") + prompt("Alarm Ack Transient") + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + interest(2) + special(SPC_NOMOD) + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + special(SPC_NOMOD) + interest(1) + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + extra("struct asgMember *asp") + prompt("Access Security Pvt") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + } + field(SPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + prompt("Address of RSET") + extra("struct typed_rset *rset") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + } + field(LSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + special(SPC_SCAN) + menu(menuPriority) + interest(1) + prompt("Scheduling Priority") + promptgroup("20 - Scan") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + initial("1") + pp(TRUE) + prompt("Undefined") + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Undefined Alarm Sevrty") + initial("INVALID") + interest(1) + menu(menuAlarmSevr) + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + special(SPC_NOMOD) + interest(2) + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VERS, DBF_FLOAT) { + initial("1") + prompt("Code Version") + special(SPC_NOMOD) + } + field(OFF, DBF_DOUBLE) { + asl(ASL0) + special(SPC_MOD) + prompt("User Offset (EGU)") + pp(TRUE) + } + field(FOFF, DBF_MENU) { + prompt("Offset-Freeze Switch") + interest(1) + promptgroup("10 - Common") + special(SPC_MOD) + asl(ASL0) + menu(motorFOFF) + } + field(FOF, DBF_SHORT) { + prompt("Freeze Offset") + interest(1) + special(SPC_MOD) + asl(ASL0) + } + field(VOF, DBF_SHORT) { + asl(ASL0) + special(SPC_MOD) + interest(1) + prompt("Variable Offset") + } + field(DIR, DBF_MENU) { + promptgroup("10 - Common") + special(SPC_MOD) + menu(motorDIR) + prompt("User Direction") + pp(TRUE) + interest(1) + } + field(SET, DBF_MENU) { + prompt("Set/Use Switch") + menu(motorSET) + asl(ASL0) + interest(1) + } + field(SSET, DBF_SHORT) { + prompt("Set SET Mode") + asl(ASL0) + special(SPC_MOD) + interest(1) + } + field(SUSE, DBF_SHORT) { + special(SPC_MOD) + asl(ASL0) + interest(1) + prompt("Set USE Mode") + } + field(VELO, DBF_DOUBLE) { + promptgroup("10 - Common") + prompt("Velocity (EGU/s)") + interest(1) + special(SPC_MOD) + } + field(VBAS, DBF_DOUBLE) { + prompt("Base Velocity (EGU/s)") + promptgroup("10 - Common") + special(SPC_MOD) + interest(1) + } + field(VMAX, DBF_DOUBLE) { + interest(1) + special(SPC_MOD) + promptgroup("10 - Common") + prompt("Max. Velocity (EGU/s)") + } + field(S, DBF_DOUBLE) { + special(SPC_MOD) + interest(1) + prompt("Speed (revolutions/sec)") + promptgroup("10 - Common") + } + field(SBAS, DBF_DOUBLE) { + promptgroup("10 - Common") + prompt("Base Speed (RPS)") + interest(1) + special(SPC_MOD) + } + field(SMAX, DBF_DOUBLE) { + interest(1) + special(SPC_MOD) + promptgroup("10 - Common") + prompt("Max. Speed (RPS)") + } + field(ACCL, DBF_DOUBLE) { + interest(1) + special(SPC_MOD) + promptgroup("10 - Common") + prompt("Seconds to Velocity") + initial("0.2") + } + field(BDST, DBF_DOUBLE) { + promptgroup("10 - Common") + prompt("BL Distance (EGU)") + interest(1) + special(SPC_MOD) + asl(ASL0) + } + field(BVEL, DBF_DOUBLE) { + prompt("BL Velocity (EGU/s)") + promptgroup("10 - Common") + special(SPC_MOD) + interest(1) + } + field(SBAK, DBF_DOUBLE) { + interest(1) + special(SPC_MOD) + promptgroup("10 - Common") + prompt("BL Speed (RPS)") + } + field(BACC, DBF_DOUBLE) { + prompt("BL Seconds to Velocity") + initial("0.5") + promptgroup("10 - Common") + special(SPC_MOD) + interest(1) + } + field(FRAC, DBF_FLOAT) { + interest(1) + special(SPC_MOD) + promptgroup("10 - Common") + initial("1") + prompt("Move Fraction") + } + field(OUT, DBF_OUTLINK) { + promptgroup("10 - Common") + prompt("Output Specification") + interest(1) + special(SPC_MOD) + } + field(CARD, DBF_SHORT) { + prompt("Card Number") + special(SPC_NOMOD) + interest(3) + } + field(RDBL, DBF_INLINK) { + special(SPC_MOD) + interest(1) + prompt("Readback Location") + promptgroup("10 - Common") + } + field(DOL, DBF_INLINK) { + special(SPC_MOD) + interest(1) + prompt("Desired Output Loc") + promptgroup("10 - Common") + } + field(OMSL, DBF_MENU) { + promptgroup("10 - Common") + prompt("Output Mode Select") + interest(1) + menu(menuOmsl) + } + field(RLNK, DBF_OUTLINK) { + special(SPC_MOD) + interest(1) + prompt("Readback OutLink") + promptgroup("10 - Common") + } + field(SREV, DBF_LONG) { + interest(1) + initial("200") + pp(TRUE) + prompt("Steps per Revolution") + special(SPC_MOD) + promptgroup("10 - Common") + } + field(UREV, DBF_DOUBLE) { + promptgroup("10 - Common") + prompt("EGU's per Revolution") + pp(TRUE) + interest(1) + special(SPC_MOD) + } + field(MRES, DBF_DOUBLE) { + prompt("Motor Step Size (EGU)") + pp(TRUE) + promptgroup("10 - Common") + special(SPC_MOD) + interest(1) + } + field(ERES, DBF_DOUBLE) { + special(SPC_MOD) + interest(1) + pp(TRUE) + prompt("Encoder Step Size (EGU)") + promptgroup("10 - Common") + } + field(RRES, DBF_DOUBLE) { + promptgroup("10 - Common") + prompt("Readback Step Size (EGU") + interest(1) + } + field(UEIP, DBF_MENU) { + pp(TRUE) + prompt("Use Encoder If Present") + interest(1) + promptgroup("10 - Common") + menu(motorUEIP) + special(SPC_MOD) + } + field(URIP, DBF_MENU) { + pp(TRUE) + prompt("Use RDBL Link If Presen") + interest(1) + promptgroup("10 - Common") + menu(motorUEIP) + special(SPC_MOD) + } + field(PREC, DBF_SHORT) { + interest(1) + promptgroup("10 - Common") + prompt("Display Precision") + } + field(EGU, DBF_STRING) { + promptgroup("10 - Common") + prompt("Engineering Units") + interest(1) + size(16) + } + field(HLM, DBF_DOUBLE) { + special(SPC_MOD) + prompt("User High Limit") + pp(TRUE) + } + field(LLM, DBF_DOUBLE) { + prompt("User Low Limit") + pp(TRUE) + special(SPC_MOD) + } + field(DHLM, DBF_DOUBLE) { + special(SPC_MOD) + promptgroup("10 - Common") + pp(TRUE) + prompt("Dial High Limit") + } + field(DLLM, DBF_DOUBLE) { + special(SPC_MOD) + promptgroup("10 - Common") + pp(TRUE) + prompt("Dial Low Limit") + } + field(HOPR, DBF_DOUBLE) { + interest(1) + promptgroup("10 - Common") + prompt("High Operating Range") + } + field(LOPR, DBF_DOUBLE) { + interest(1) + promptgroup("10 - Common") + prompt("Low Operating Range") + } + field(HLS, DBF_SHORT) { + special(SPC_NOMOD) + prompt("User High Limit Switch") + } + field(LLS, DBF_SHORT) { + prompt("User Low Limit Switch") + special(SPC_NOMOD) + } + field(RHLS, DBF_SHORT) { + special(SPC_NOMOD) + prompt("Raw High Limit Switch") + } + field(RLLS, DBF_SHORT) { + special(SPC_NOMOD) + prompt("Raw Low Limit Switch") + } + field(HIHI, DBF_DOUBLE) { + interest(2) + pp(TRUE) + prompt("Hihi Alarm Limit (EGU)") + promptgroup("10 - Common") + } + field(LOLO, DBF_DOUBLE) { + prompt("Lolo Alarm Limit (EGU)") + pp(TRUE) + promptgroup("10 - Common") + interest(2) + } + field(HIGH, DBF_DOUBLE) { + interest(2) + pp(TRUE) + prompt("High Alarm Limit (EGU)") + promptgroup("10 - Common") + } + field(LOW, DBF_DOUBLE) { + prompt("Low Alarm Limit (EGU)") + pp(TRUE) + promptgroup("10 - Common") + interest(2) + } + field(HHSV, DBF_MENU) { + promptgroup("10 - Common") + prompt("Hihi Severity") + pp(TRUE) + interest(2) + menu(menuAlarmSevr) + } + field(LLSV, DBF_MENU) { + promptgroup("10 - Common") + prompt("Lolo Severity") + pp(TRUE) + interest(2) + menu(menuAlarmSevr) + } + field(HSV, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + promptgroup("10 - Common") + prompt("High Severity") + pp(TRUE) + } + field(LSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(2) + prompt("Low Severity") + pp(TRUE) + promptgroup("10 - Common") + } + field(HLSV, DBF_MENU) { + prompt("HW Limit Violation Svr") + pp(TRUE) + promptgroup("10 - Common") + menu(menuAlarmSevr) + interest(2) + } + field(RDBD, DBF_DOUBLE) { + promptgroup("10 - Common") + prompt("Retry Deadband (EGU)") + interest(1) + special(SPC_MOD) + } + field(SPDB, DBF_DOUBLE) { + interest(1) + special(SPC_MOD) + promptgroup("10 - Common") + prompt("Setpoint Deadband (EGU)") + } + field(RCNT, DBF_SHORT) { + special(SPC_NOMOD) + interest(2) + prompt("Retry count") + } + field(RTRY, DBF_SHORT) { + interest(1) + prompt("Max retry count") + initial("10") + promptgroup("10 - Common") + } + field(MISS, DBF_SHORT) { + prompt("Ran out of retries") + special(SPC_NOMOD) + interest(2) + } + field(SPMG, DBF_MENU) { + menu(motorSPMG) + asl(ASL0) + prompt("Stop/Pause/Move/Go") + pp(TRUE) + initial("3") + interest(1) + } + field(LSPG, DBF_MENU) { + special(SPC_NOMOD) + menu(motorSPMG) + interest(1) + initial("3") + prompt("Last SPMG") + } + field(STOP, DBF_SHORT) { + prompt("Stop") + pp(TRUE) + interest(1) + asl(ASL0) + } + field(HOMF, DBF_SHORT) { + prompt("Home Forward") + pp(TRUE) + interest(1) + special(SPC_MOD) + } + field(HOMR, DBF_SHORT) { + prompt("Home Reverse") + pp(TRUE) + special(SPC_MOD) + interest(1) + } + field(JOGF, DBF_SHORT) { + prompt("Jog motor Forward") + pp(TRUE) + special(SPC_MOD) + asl(ASL0) + interest(1) + } + field(JOGR, DBF_SHORT) { + special(SPC_MOD) + asl(ASL0) + interest(1) + pp(TRUE) + prompt("Jog motor Reverse") + } + field(TWF, DBF_SHORT) { + special(SPC_MOD) + asl(ASL0) + interest(1) + pp(TRUE) + prompt("Tweak motor Forward") + } + field(TWR, DBF_SHORT) { + asl(ASL0) + special(SPC_MOD) + interest(1) + pp(TRUE) + prompt("Tweak motor Reverse") + } + field(TWV, DBF_DOUBLE) { + prompt("Tweak Step Size (EGU)") + promptgroup("10 - Common") + asl(ASL0) + interest(1) + } + field(VAL, DBF_DOUBLE) { + special(SPC_MOD) + asl(ASL0) + pp(TRUE) + prompt("User Desired Value (EGU") + } + field(LVAL, DBF_DOUBLE) { + prompt("Last User Des Val (EGU)") + interest(1) + special(SPC_NOMOD) + } + field(DVAL, DBF_DOUBLE) { + special(SPC_MOD) + asl(ASL0) + pp(TRUE) + prompt("Dial Desired Value (EGU") + } + field(LDVL, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(1) + prompt("Last Dial Des Val (EGU)") + } + field(RVAL, DBF_LONG) { + prompt("Raw Desired Value (step") + pp(TRUE) + asl(ASL0) + special(SPC_MOD) + } + field(LRVL, DBF_LONG) { + special(SPC_NOMOD) + interest(1) + prompt("Last Raw Des Val (steps") + } + field(RLV, DBF_DOUBLE) { + pp(TRUE) + prompt("Relative Value (EGU)") + special(SPC_MOD) + asl(ASL0) + } + field(LRLV, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(1) + prompt("Last Rel Value (EGU)") + } + field(RBV, DBF_DOUBLE) { + prompt("User Readback Value") + special(SPC_NOMOD) + } + field(DRBV, DBF_DOUBLE) { + special(SPC_NOMOD) + prompt("Dial Readback Value") + } + field(DIFF, DBF_DOUBLE) { + special(SPC_NOMOD) + prompt("Difference dval-drbv") + } + field(RDIF, DBF_LONG) { + special(SPC_NOMOD) + prompt("Difference rval-rrbv") + } + field(CDIR, DBF_SHORT) { + prompt("Raw cmnd direction") + special(SPC_NOMOD) + } + field(RRBV, DBF_LONG) { + special(SPC_NOMOD) + prompt("Raw Readback Value") + } + field(RMP, DBF_LONG) { + prompt("Raw Motor Position") + special(SPC_NOMOD) + } + field(REP, DBF_LONG) { + prompt("Raw Encoder Position") + special(SPC_NOMOD) + } + field(RVEL, DBF_LONG) { + promptgroup("10 - Common") + prompt("Raw Velocity") + interest(1) + special(SPC_NOMOD) + } + field(DMOV, DBF_SHORT) { + promptgroup("10 - Common") + prompt("Done moving to value") + initial("1") + special(SPC_NOMOD) + } + field(MOVN, DBF_SHORT) { + special(SPC_NOMOD) + prompt("Motor is moving") + } + field(MSTA, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + prompt("Motor Status") + } + field(LVIO, DBF_SHORT) { + initial("1") + prompt("Limit violation") + special(SPC_NOMOD) + } + field(TDIR, DBF_SHORT) { + special(SPC_NOMOD) + prompt("Direction of Travel") + } + field(ATHM, DBF_SHORT) { + prompt("At HOME") + special(SPC_NOMOD) + } + field(PP, DBF_SHORT) { + interest(2) + special(SPC_NOMOD) + prompt("Post process command") + initial("0") + } + field(MIP, DBF_USHORT) { + interest(3) + special(SPC_NOMOD) + prompt("Motion In Progress") + } + field(MMAP, DBF_ULONG) { + prompt("Monitor Mask") + interest(3) + special(SPC_NOMOD) + } + field(NMAP, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + prompt("Monitor Mask (more)") + } + field(DLY, DBF_DOUBLE) { + interest(1) + special(SPC_MOD) + promptgroup("10 - Common") + prompt("Readback settle time (s)") + } + field(CBAK, DBF_NOACCESS) { + prompt("Callback structure") + extra("void *cbak") + size(4) + special(SPC_NOMOD) + interest(4) + } + field(PCOF, DBF_DOUBLE) { + promptgroup("10 - Common") + prompt("Proportional Gain") + initial("0") + interest(1) + special(SPC_MOD) + } + field(ICOF, DBF_DOUBLE) { + initial("0") + prompt("Integral Gain") + promptgroup("10 - Common") + special(SPC_MOD) + interest(1) + } + field(DCOF, DBF_DOUBLE) { + special(SPC_MOD) + interest(1) + initial("0") + prompt("Derivative Gain") + promptgroup("10 - Common") + } + field(CNEN, DBF_MENU) { + special(SPC_MOD) + menu(motorTORQ) + asl(ASL0) + promptgroup("10 - Common") + prompt("Enable control") + pp(TRUE) + } + field(INIT, DBF_STRING) { + promptgroup("10 - Common") + prompt("Startup commands") + interest(1) + size(40) + } + field(PREM, DBF_STRING) { + interest(1) + size(40) + promptgroup("10 - Common") + prompt("Pre-move commands") + } + field(POST, DBF_STRING) { + prompt("Post-move commands") + promptgroup("10 - Common") + size(40) + interest(1) + } + field(STOO, DBF_OUTLINK) { + special(SPC_MOD) + interest(1) + prompt("STOP OutLink") + promptgroup("10 - Common") + } + field(DINP, DBF_INLINK) { + special(SPC_MOD) + interest(1) + prompt("DMOV Input Link") + promptgroup("10 - Common") + } + field(RINP, DBF_INLINK) { + prompt("RMP Input Link") + promptgroup("10 - Common") + special(SPC_MOD) + interest(1) + } + field(JVEL, DBF_DOUBLE) { + prompt("Jog Velocity (EGU/s)") + promptgroup("10 - Common") + special(SPC_MOD) + interest(1) + } + field(JAR, DBF_DOUBLE) { + prompt("Jog Accel. (EGU/s^2)") + promptgroup("10 - Common") + special(SPC_MOD) + interest(1) + } + field(LOCK, DBF_MENU) { + interest(1) + menu(menuYesNo) + promptgroup("10 - Common") + prompt("Soft Channel Position Lock") + initial("NO") + } + field(NTM, DBF_MENU) { + interest(1) + menu(menuYesNo) + promptgroup("10 - Common") + prompt("New Target Monitor") + initial("YES") + } + field(NTMF, DBF_USHORT) { + promptgroup("10 - Common") + prompt("NTM Deadband Factor") + initial("2") + interest(1) + special(SPC_MOD) + } + field(HVEL, DBF_DOUBLE) { + promptgroup("10 - Common") + prompt("Home Velocity (EGU/s)") + interest(1) + special(SPC_MOD) + } + field(STUP, DBF_MENU) { + promptgroup("10 - Common") + menu(motorSTUP) + asl(ASL0) + special(SPC_MOD) + prompt("Status Update") + initial("OFF") + pp(TRUE) + interest(3) + } + field(RMOD, DBF_MENU) { + interest(1) + menu(motorRMOD) + promptgroup("10 - Common") + prompt("Retry Mode") + initial("Default") + } + field(ADEL, DBF_DOUBLE) { + interest(1) + prompt("Archive Deadband") + promptgroup("10 - Common") + } + field(MDEL, DBF_DOUBLE) { + promptgroup("10 - Common") + prompt("Monitor Deadband") + interest(1) + } + field(ALST, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Archived") + } + field(MLST, DBF_DOUBLE) { + prompt("Last Val Monitored") + special(SPC_NOMOD) + interest(3) + } + field(SYNC, DBF_SHORT) { + pp(TRUE) + prompt("Sync position") + interest(1) + } + field(IGSET, DBF_SHORT) { + interest(2) + prompt("Ignore SET field") + } +} +device(motor, INST_IO, devMotorAsyn, "asynMotor") +recordtype(aSub) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %struct aSubRecord; + field(NAME, DBF_STRING) { + prompt("Record Name") + special(SPC_NOMOD) + size(61) + } + field(DESC, DBF_STRING) { + size(41) + prompt("Descriptor") + promptgroup("10 - Common") + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + special(SPC_SCAN) + menu(menuScan) + interest(1) + prompt("Scan Mechanism") + promptgroup("20 - Scan") + } + field(PINI, DBF_MENU) { + interest(1) + menu(menuPini) + promptgroup("20 - Scan") + prompt("Process at iocInit") + } + field(PHAS, DBF_SHORT) { + special(SPC_SCAN) + interest(1) + prompt("Scan Phase") + promptgroup("20 - Scan") + } + field(EVNT, DBF_STRING) { + interest(1) + special(SPC_SCAN) + size(40) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + prompt("Time Stamp Event") + promptgroup("20 - Scan") + interest(1) + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + interest(4) + special(SPC_NOMOD) + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + pp(TRUE) + prompt("Force Processing") + interest(3) + } + field(STAT, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(ACKS, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + special(SPC_NOMOD) + menu(menuYesNo) + interest(2) + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + interest(1) + special(SPC_NOMOD) + } + field(RPRO, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + prompt("Access Security Pvt") + extra("struct asgMember *asp") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct scan_element *spvt") + prompt("Scan Private") + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + special(SPC_NOMOD) + interest(4) + } + field(LSET, DBF_NOACCESS) { + extra("struct lockRecord *lset") + prompt("Lock Set") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + menu(menuPriority) + special(SPC_SCAN) + interest(1) + prompt("Scheduling Priority") + promptgroup("20 - Scan") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + interest(1) + prompt("Undefined") + initial("1") + pp(TRUE) + promptgroup("10 - Common") + } + field(UDFS, DBF_MENU) { + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(TIME, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_LONG) { + prompt("Subr. return value") + asl(ASL0) + } + field(OVAL, DBF_LONG) { + special(SPC_NOMOD) + interest(3) + prompt("Old return value") + } + field(INAM, DBF_STRING) { + promptgroup("30 - Action") + prompt("Initialize Subr. Name") + interest(1) + special(SPC_NOMOD) + size(41) + } + field(LFLG, DBF_MENU) { + promptgroup("30 - Action") + prompt("Subr. Input Enable") + interest(1) + menu(aSubLFLG) + } + field(SUBL, DBF_INLINK) { + prompt("Subroutine Name Link") + promptgroup("30 - Action") + special(SPC_NOMOD) + interest(1) + } + field(SNAM, DBF_STRING) { + interest(1) + special(SPC_MOD) + size(41) + promptgroup("30 - Action") + prompt("Process Subr. Name") + } + field(ONAM, DBF_STRING) { + interest(3) + size(41) + special(SPC_NOMOD) + promptgroup("30 - Action") + prompt("Old Subr. Name") + } + field(SADR, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + extra("long (*sadr)(struct aSubRecord *)") + prompt("Subroutine Address") + } + field(CADR, DBF_NOACCESS) { + extra("void (*cadr)(struct aSubRecord *)") + prompt("Subroutine Cleanup Address") + special(SPC_NOMOD) + interest(2) + } + field(BRSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Bad Return Severity") + pp(TRUE) + } + field(PREC, DBF_SHORT) { + interest(1) + prop(YES) + promptgroup("80 - Display") + prompt("Display Precision") + } + field(EFLG, DBF_MENU) { + interest(1) + menu(aSubEFLG) + promptgroup("50 - Output") + initial("1") + prompt("Output Event Flag") + } + field(INPA, DBF_INLINK) { + interest(1) + prompt("Input Link A") + promptgroup("41 - Input A-G") + } + field(INPB, DBF_INLINK) { + interest(1) + promptgroup("41 - Input A-G") + prompt("Input Link B") + } + field(INPC, DBF_INLINK) { + prompt("Input Link C") + promptgroup("41 - Input A-G") + interest(1) + } + field(INPD, DBF_INLINK) { + interest(1) + promptgroup("41 - Input A-G") + prompt("Input Link D") + } + field(INPE, DBF_INLINK) { + interest(1) + promptgroup("41 - Input A-G") + prompt("Input Link E") + } + field(INPF, DBF_INLINK) { + prompt("Input Link F") + promptgroup("41 - Input A-G") + interest(1) + } + field(INPG, DBF_INLINK) { + interest(1) + promptgroup("41 - Input A-G") + prompt("Input Link G") + } + field(INPH, DBF_INLINK) { + interest(1) + promptgroup("42 - Input H-N") + prompt("Input Link H") + } + field(INPI, DBF_INLINK) { + interest(1) + promptgroup("42 - Input H-N") + prompt("Input Link I") + } + field(INPJ, DBF_INLINK) { + interest(1) + prompt("Input Link J") + promptgroup("42 - Input H-N") + } + field(INPK, DBF_INLINK) { + promptgroup("42 - Input H-N") + prompt("Input Link K") + interest(1) + } + field(INPL, DBF_INLINK) { + prompt("Input Link L") + promptgroup("42 - Input H-N") + interest(1) + } + field(INPM, DBF_INLINK) { + promptgroup("42 - Input H-N") + prompt("Input Link M") + interest(1) + } + field(INPN, DBF_INLINK) { + interest(1) + promptgroup("42 - Input H-N") + prompt("Input Link N") + } + field(INPO, DBF_INLINK) { + interest(1) + promptgroup("43 - Input O-U") + prompt("Input Link O") + } + field(INPP, DBF_INLINK) { + prompt("Input Link P") + promptgroup("43 - Input O-U") + interest(1) + } + field(INPQ, DBF_INLINK) { + promptgroup("43 - Input O-U") + prompt("Input Link Q") + interest(1) + } + field(INPR, DBF_INLINK) { + interest(1) + promptgroup("43 - Input O-U") + prompt("Input Link R") + } + field(INPS, DBF_INLINK) { + promptgroup("43 - Input O-U") + prompt("Input Link S") + interest(1) + } + field(INPT, DBF_INLINK) { + prompt("Input Link T") + promptgroup("43 - Input O-U") + interest(1) + } + field(INPU, DBF_INLINK) { + promptgroup("43 - Input O-U") + prompt("Input Link U") + interest(1) + } + field(A, DBF_NOACCESS) { + prompt("Input value A") + extra("void *a") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + } + field(B, DBF_NOACCESS) { + interest(2) + asl(ASL0) + special(SPC_DBADDR) + extra("void *b") + prompt("Input value B") + } + field(C, DBF_NOACCESS) { + extra("void *c") + prompt("Input value C") + special(SPC_DBADDR) + asl(ASL0) + interest(2) + } + field(D, DBF_NOACCESS) { + interest(2) + special(SPC_DBADDR) + asl(ASL0) + extra("void *d") + prompt("Input value D") + } + field(E, DBF_NOACCESS) { + interest(2) + asl(ASL0) + special(SPC_DBADDR) + extra("void *e") + prompt("Input value E") + } + field(F, DBF_NOACCESS) { + extra("void *f") + prompt("Input value F") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + } + field(G, DBF_NOACCESS) { + prompt("Input value G") + extra("void *g") + interest(2) + asl(ASL0) + special(SPC_DBADDR) + } + field(H, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + interest(2) + prompt("Input value H") + extra("void *h") + } + field(I, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + interest(2) + prompt("Input value I") + extra("void *i") + } + field(J, DBF_NOACCESS) { + extra("void *j") + prompt("Input value J") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + } + field(K, DBF_NOACCESS) { + prompt("Input value K") + extra("void *k") + special(SPC_DBADDR) + asl(ASL0) + interest(2) + } + field(L, DBF_NOACCESS) { + interest(2) + asl(ASL0) + special(SPC_DBADDR) + extra("void *l") + prompt("Input value L") + } + field(M, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *m") + prompt("Input value M") + } + field(N, DBF_NOACCESS) { + special(SPC_DBADDR) + asl(ASL0) + interest(2) + extra("void *n") + prompt("Input value N") + } + field(O, DBF_NOACCESS) { + interest(2) + asl(ASL0) + special(SPC_DBADDR) + prompt("Input value O") + extra("void *o") + } + field(P, DBF_NOACCESS) { + interest(2) + special(SPC_DBADDR) + asl(ASL0) + extra("void *p") + prompt("Input value P") + } + field(Q, DBF_NOACCESS) { + special(SPC_DBADDR) + asl(ASL0) + interest(2) + extra("void *q") + prompt("Input value Q") + } + field(R, DBF_NOACCESS) { + prompt("Input value R") + extra("void *r") + interest(2) + asl(ASL0) + special(SPC_DBADDR) + } + field(S, DBF_NOACCESS) { + interest(2) + special(SPC_DBADDR) + asl(ASL0) + extra("void *s") + prompt("Input value S") + } + field(T, DBF_NOACCESS) { + interest(2) + special(SPC_DBADDR) + asl(ASL0) + prompt("Input value T") + extra("void *t") + } + field(U, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + interest(2) + prompt("Input value U") + extra("void *u") + } + field(FTA, DBF_MENU) { + prompt("Type of A") + initial("DOUBLE") + interest(1) + promptgroup("41 - Input A-G") + special(SPC_NOMOD) + menu(menuFtype) + } + field(FTB, DBF_MENU) { + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("41 - Input A-G") + interest(1) + initial("DOUBLE") + prompt("Type of B") + } + field(FTC, DBF_MENU) { + special(SPC_NOMOD) + menu(menuFtype) + promptgroup("41 - Input A-G") + interest(1) + initial("DOUBLE") + prompt("Type of C") + } + field(FTD, DBF_MENU) { + promptgroup("41 - Input A-G") + special(SPC_NOMOD) + menu(menuFtype) + prompt("Type of D") + initial("DOUBLE") + interest(1) + } + field(FTE, DBF_MENU) { + special(SPC_NOMOD) + menu(menuFtype) + promptgroup("41 - Input A-G") + interest(1) + initial("DOUBLE") + prompt("Type of E") + } + field(FTF, DBF_MENU) { + initial("DOUBLE") + prompt("Type of F") + interest(1) + promptgroup("41 - Input A-G") + menu(menuFtype) + special(SPC_NOMOD) + } + field(FTG, DBF_MENU) { + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("41 - Input A-G") + interest(1) + initial("DOUBLE") + prompt("Type of G") + } + field(FTH, DBF_MENU) { + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("42 - Input H-N") + interest(1) + prompt("Type of H") + initial("DOUBLE") + } + field(FTI, DBF_MENU) { + initial("DOUBLE") + prompt("Type of I") + interest(1) + promptgroup("42 - Input H-N") + special(SPC_NOMOD) + menu(menuFtype) + } + field(FTJ, DBF_MENU) { + initial("DOUBLE") + prompt("Type of J") + interest(1) + promptgroup("42 - Input H-N") + special(SPC_NOMOD) + menu(menuFtype) + } + field(FTK, DBF_MENU) { + initial("DOUBLE") + prompt("Type of K") + interest(1) + promptgroup("42 - Input H-N") + menu(menuFtype) + special(SPC_NOMOD) + } + field(FTL, DBF_MENU) { + interest(1) + initial("DOUBLE") + prompt("Type of L") + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("42 - Input H-N") + } + field(FTM, DBF_MENU) { + prompt("Type of M") + initial("DOUBLE") + interest(1) + promptgroup("42 - Input H-N") + menu(menuFtype) + special(SPC_NOMOD) + } + field(FTN, DBF_MENU) { + interest(1) + prompt("Type of N") + initial("DOUBLE") + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("42 - Input H-N") + } + field(FTO, DBF_MENU) { + promptgroup("43 - Input O-U") + special(SPC_NOMOD) + menu(menuFtype) + prompt("Type of O") + initial("DOUBLE") + interest(1) + } + field(FTP, DBF_MENU) { + promptgroup("43 - Input O-U") + menu(menuFtype) + special(SPC_NOMOD) + prompt("Type of P") + initial("DOUBLE") + interest(1) + } + field(FTQ, DBF_MENU) { + promptgroup("43 - Input O-U") + menu(menuFtype) + special(SPC_NOMOD) + prompt("Type of Q") + initial("DOUBLE") + interest(1) + } + field(FTR, DBF_MENU) { + prompt("Type of R") + initial("DOUBLE") + interest(1) + promptgroup("43 - Input O-U") + menu(menuFtype) + special(SPC_NOMOD) + } + field(FTS, DBF_MENU) { + promptgroup("43 - Input O-U") + special(SPC_NOMOD) + menu(menuFtype) + initial("DOUBLE") + prompt("Type of S") + interest(1) + } + field(FTT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuFtype) + promptgroup("43 - Input O-U") + interest(1) + initial("DOUBLE") + prompt("Type of T") + } + field(FTU, DBF_MENU) { + special(SPC_NOMOD) + menu(menuFtype) + promptgroup("43 - Input O-U") + interest(1) + initial("DOUBLE") + prompt("Type of U") + } + field(NOA, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("41 - Input A-G") + prompt("Max. elements in A") + initial("1") + } + field(NOB, DBF_ULONG) { + promptgroup("41 - Input A-G") + initial("1") + prompt("Max. elements in B") + interest(1) + special(SPC_NOMOD) + } + field(NOC, DBF_ULONG) { + initial("1") + prompt("Max. elements in C") + promptgroup("41 - Input A-G") + special(SPC_NOMOD) + interest(1) + } + field(NOD, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + initial("1") + prompt("Max. elements in D") + promptgroup("41 - Input A-G") + } + field(NOE, DBF_ULONG) { + initial("1") + prompt("Max. elements in E") + promptgroup("41 - Input A-G") + special(SPC_NOMOD) + interest(1) + } + field(NOF, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("41 - Input A-G") + initial("1") + prompt("Max. elements in F") + } + field(NOG, DBF_ULONG) { + prompt("Max. elements in G") + initial("1") + promptgroup("41 - Input A-G") + special(SPC_NOMOD) + interest(1) + } + field(NOH, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("42 - Input H-N") + prompt("Max. elements in H") + initial("1") + } + field(NOI, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + initial("1") + prompt("Max. elements in I") + promptgroup("42 - Input H-N") + } + field(NOJ, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("42 - Input H-N") + initial("1") + prompt("Max. elements in J") + } + field(NOK, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + initial("1") + prompt("Max. elements in K") + promptgroup("42 - Input H-N") + } + field(NOL, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + prompt("Max. elements in L") + initial("1") + promptgroup("42 - Input H-N") + } + field(NOM, DBF_ULONG) { + promptgroup("42 - Input H-N") + prompt("Max. elements in M") + initial("1") + interest(1) + special(SPC_NOMOD) + } + field(NON, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("42 - Input H-N") + prompt("Max. elements in N") + initial("1") + } + field(NOO, DBF_ULONG) { + prompt("Max. elements in O") + initial("1") + promptgroup("43 - Input O-U") + special(SPC_NOMOD) + interest(1) + } + field(NOP, DBF_ULONG) { + promptgroup("43 - Input O-U") + initial("1") + prompt("Max. elements in P") + interest(1) + special(SPC_NOMOD) + } + field(NOQ, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("43 - Input O-U") + initial("1") + prompt("Max. elements in Q") + } + field(NOR, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("43 - Input O-U") + initial("1") + prompt("Max. elements in R") + } + field(NOS, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + prompt("Max. elements in S") + initial("1") + promptgroup("43 - Input O-U") + } + field(NOT, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("43 - Input O-U") + initial("1") + prompt("Max. elements in T") + } + field(NOU, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("43 - Input O-U") + prompt("Max. elements in U") + initial("1") + } + field(NEA, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + initial("1") + prompt("Num. elements in A") + } + field(NEB, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + prompt("Num. elements in B") + initial("1") + } + field(NEC, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + initial("1") + prompt("Num. elements in C") + } + field(NED, DBF_ULONG) { + prompt("Num. elements in D") + initial("1") + interest(3) + special(SPC_NOMOD) + } + field(NEE, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + initial("1") + prompt("Num. elements in E") + } + field(NEF, DBF_ULONG) { + initial("1") + prompt("Num. elements in F") + interest(3) + special(SPC_NOMOD) + } + field(NEG, DBF_ULONG) { + prompt("Num. elements in G") + initial("1") + special(SPC_NOMOD) + interest(3) + } + field(NEH, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + initial("1") + prompt("Num. elements in H") + } + field(NEI, DBF_ULONG) { + initial("1") + prompt("Num. elements in I") + special(SPC_NOMOD) + interest(3) + } + field(NEJ, DBF_ULONG) { + initial("1") + prompt("Num. elements in J") + special(SPC_NOMOD) + interest(3) + } + field(NEK, DBF_ULONG) { + prompt("Num. elements in K") + initial("1") + interest(3) + special(SPC_NOMOD) + } + field(NEL, DBF_ULONG) { + initial("1") + prompt("Num. elements in L") + interest(3) + special(SPC_NOMOD) + } + field(NEM, DBF_ULONG) { + initial("1") + prompt("Num. elements in M") + special(SPC_NOMOD) + interest(3) + } + field(NEN, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + prompt("Num. elements in N") + initial("1") + } + field(NEO, DBF_ULONG) { + initial("1") + prompt("Num. elements in O") + interest(3) + special(SPC_NOMOD) + } + field(NEP, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + initial("1") + prompt("Num. elements in P") + } + field(NEQ, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + initial("1") + prompt("Num. elements in Q") + } + field(NER, DBF_ULONG) { + prompt("Num. elements in R") + initial("1") + special(SPC_NOMOD) + interest(3) + } + field(NES, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + prompt("Num. elements in S") + initial("1") + } + field(NET, DBF_ULONG) { + initial("1") + prompt("Num. elements in T") + interest(3) + special(SPC_NOMOD) + } + field(NEU, DBF_ULONG) { + initial("1") + prompt("Num. elements in U") + special(SPC_NOMOD) + interest(3) + } + field(OUTA, DBF_OUTLINK) { + prompt("Output Link A") + promptgroup("51 - Output A-G") + interest(1) + } + field(OUTB, DBF_OUTLINK) { + prompt("Output Link B") + promptgroup("51 - Output A-G") + interest(1) + } + field(OUTC, DBF_OUTLINK) { + promptgroup("51 - Output A-G") + prompt("Output Link C") + interest(1) + } + field(OUTD, DBF_OUTLINK) { + promptgroup("51 - Output A-G") + prompt("Output Link D") + interest(1) + } + field(OUTE, DBF_OUTLINK) { + interest(1) + promptgroup("51 - Output A-G") + prompt("Output Link E") + } + field(OUTF, DBF_OUTLINK) { + interest(1) + promptgroup("51 - Output A-G") + prompt("Output Link F") + } + field(OUTG, DBF_OUTLINK) { + prompt("Output Link G") + promptgroup("51 - Output A-G") + interest(1) + } + field(OUTH, DBF_OUTLINK) { + interest(1) + prompt("Output Link H") + promptgroup("52 - Output H-N") + } + field(OUTI, DBF_OUTLINK) { + interest(1) + promptgroup("52 - Output H-N") + prompt("Output Link I") + } + field(OUTJ, DBF_OUTLINK) { + interest(1) + promptgroup("52 - Output H-N") + prompt("Output Link J") + } + field(OUTK, DBF_OUTLINK) { + interest(1) + prompt("Output Link K") + promptgroup("52 - Output H-N") + } + field(OUTL, DBF_OUTLINK) { + prompt("Output Link L") + promptgroup("52 - Output H-N") + interest(1) + } + field(OUTM, DBF_OUTLINK) { + interest(1) + prompt("Output Link M") + promptgroup("52 - Output H-N") + } + field(OUTN, DBF_OUTLINK) { + interest(1) + prompt("Output Link N") + promptgroup("52 - Output H-N") + } + field(OUTO, DBF_OUTLINK) { + interest(1) + promptgroup("53 - Output O-U") + prompt("Output Link O") + } + field(OUTP, DBF_OUTLINK) { + interest(1) + promptgroup("53 - Output O-U") + prompt("Output Link P") + } + field(OUTQ, DBF_OUTLINK) { + interest(1) + promptgroup("53 - Output O-U") + prompt("Output Link Q") + } + field(OUTR, DBF_OUTLINK) { + interest(1) + prompt("Output Link R") + promptgroup("53 - Output O-U") + } + field(OUTS, DBF_OUTLINK) { + promptgroup("53 - Output O-U") + prompt("Output Link S") + interest(1) + } + field(OUTT, DBF_OUTLINK) { + interest(1) + prompt("Output Link T") + promptgroup("53 - Output O-U") + } + field(OUTU, DBF_OUTLINK) { + prompt("Output Link U") + promptgroup("53 - Output O-U") + interest(1) + } + field(VALA, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + interest(2) + prompt("Output value A") + extra("void *vala") + } + field(VALB, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valb") + prompt("Output value B") + } + field(VALC, DBF_NOACCESS) { + special(SPC_DBADDR) + asl(ASL0) + interest(2) + extra("void *valc") + prompt("Output value C") + } + field(VALD, DBF_NOACCESS) { + prompt("Output value D") + extra("void *vald") + interest(2) + special(SPC_DBADDR) + asl(ASL0) + } + field(VALE, DBF_NOACCESS) { + special(SPC_DBADDR) + asl(ASL0) + interest(2) + prompt("Output value E") + extra("void *vale") + } + field(VALF, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + interest(2) + prompt("Output value F") + extra("void *valf") + } + field(VALG, DBF_NOACCESS) { + interest(2) + asl(ASL0) + special(SPC_DBADDR) + prompt("Output value G") + extra("void *valg") + } + field(VALH, DBF_NOACCESS) { + prompt("Output value H") + extra("void *valh") + special(SPC_DBADDR) + asl(ASL0) + interest(2) + } + field(VALI, DBF_NOACCESS) { + extra("void *vali") + prompt("Output value I") + interest(2) + special(SPC_DBADDR) + asl(ASL0) + } + field(VALJ, DBF_NOACCESS) { + extra("void *valj") + prompt("Output value J") + special(SPC_DBADDR) + asl(ASL0) + interest(2) + } + field(VALK, DBF_NOACCESS) { + special(SPC_DBADDR) + asl(ASL0) + interest(2) + extra("void *valk") + prompt("Output value K") + } + field(VALL, DBF_NOACCESS) { + special(SPC_DBADDR) + asl(ASL0) + interest(2) + prompt("Output value L") + extra("void *vall") + } + field(VALM, DBF_NOACCESS) { + prompt("Output value M") + extra("void *valm") + interest(2) + special(SPC_DBADDR) + asl(ASL0) + } + field(VALN, DBF_NOACCESS) { + extra("void *valn") + prompt("Output value N") + asl(ASL0) + special(SPC_DBADDR) + interest(2) + } + field(VALO, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + interest(2) + extra("void *valo") + prompt("Output value O") + } + field(VALP, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + interest(2) + prompt("Output value P") + extra("void *valp") + } + field(VALQ, DBF_NOACCESS) { + special(SPC_DBADDR) + asl(ASL0) + interest(2) + extra("void *valq") + prompt("Output value Q") + } + field(VALR, DBF_NOACCESS) { + extra("void *valr") + prompt("Output value R") + special(SPC_DBADDR) + asl(ASL0) + interest(2) + } + field(VALS, DBF_NOACCESS) { + extra("void *vals") + prompt("Output value S") + special(SPC_DBADDR) + asl(ASL0) + interest(2) + } + field(VALT, DBF_NOACCESS) { + extra("void *valt") + prompt("Output value T") + interest(2) + asl(ASL0) + special(SPC_DBADDR) + } + field(VALU, DBF_NOACCESS) { + prompt("Output value U") + extra("void *valu") + interest(2) + special(SPC_DBADDR) + asl(ASL0) + } + field(OVLA, DBF_NOACCESS) { + special(SPC_NOMOD) + asl(ASL0) + interest(4) + prompt("Old Output A") + extra("void *ovla") + } + field(OVLB, DBF_NOACCESS) { + extra("void *ovlb") + prompt("Old Output B") + interest(4) + special(SPC_NOMOD) + asl(ASL0) + } + field(OVLC, DBF_NOACCESS) { + prompt("Old Output C") + extra("void *ovlc") + interest(4) + asl(ASL0) + special(SPC_NOMOD) + } + field(OVLD, DBF_NOACCESS) { + interest(4) + asl(ASL0) + special(SPC_NOMOD) + prompt("Old Output D") + extra("void *ovld") + } + field(OVLE, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + asl(ASL0) + extra("void *ovle") + prompt("Old Output E") + } + field(OVLF, DBF_NOACCESS) { + prompt("Old Output F") + extra("void *ovlf") + special(SPC_NOMOD) + asl(ASL0) + interest(4) + } + field(OVLG, DBF_NOACCESS) { + extra("void *ovlg") + prompt("Old Output G") + interest(4) + asl(ASL0) + special(SPC_NOMOD) + } + field(OVLH, DBF_NOACCESS) { + prompt("Old Output H") + extra("void *ovlh") + interest(4) + asl(ASL0) + special(SPC_NOMOD) + } + field(OVLI, DBF_NOACCESS) { + prompt("Old Output I") + extra("void *ovli") + asl(ASL0) + special(SPC_NOMOD) + interest(4) + } + field(OVLJ, DBF_NOACCESS) { + prompt("Old Output J") + extra("void *ovlj") + asl(ASL0) + special(SPC_NOMOD) + interest(4) + } + field(OVLK, DBF_NOACCESS) { + asl(ASL0) + special(SPC_NOMOD) + interest(4) + extra("void *ovlk") + prompt("Old Output K") + } + field(OVLL, DBF_NOACCESS) { + extra("void *ovll") + prompt("Old Output L") + special(SPC_NOMOD) + asl(ASL0) + interest(4) + } + field(OVLM, DBF_NOACCESS) { + special(SPC_NOMOD) + asl(ASL0) + interest(4) + prompt("Old Output M") + extra("void *ovlm") + } + field(OVLN, DBF_NOACCESS) { + interest(4) + asl(ASL0) + special(SPC_NOMOD) + prompt("Old Output N") + extra("void *ovln") + } + field(OVLO, DBF_NOACCESS) { + asl(ASL0) + special(SPC_NOMOD) + interest(4) + prompt("Old Output O") + extra("void *ovlo") + } + field(OVLP, DBF_NOACCESS) { + special(SPC_NOMOD) + asl(ASL0) + interest(4) + extra("void *ovlp") + prompt("Old Output P") + } + field(OVLQ, DBF_NOACCESS) { + prompt("Old Output Q") + extra("void *ovlq") + special(SPC_NOMOD) + asl(ASL0) + interest(4) + } + field(OVLR, DBF_NOACCESS) { + extra("void *ovlr") + prompt("Old Output R") + interest(4) + asl(ASL0) + special(SPC_NOMOD) + } + field(OVLS, DBF_NOACCESS) { + special(SPC_NOMOD) + asl(ASL0) + interest(4) + prompt("Old Output S") + extra("void *ovls") + } + field(OVLT, DBF_NOACCESS) { + interest(4) + asl(ASL0) + special(SPC_NOMOD) + extra("void *ovlt") + prompt("Old Output T") + } + field(OVLU, DBF_NOACCESS) { + interest(4) + asl(ASL0) + special(SPC_NOMOD) + prompt("Old Output U") + extra("void *ovlu") + } + field(FTVA, DBF_MENU) { + promptgroup("51 - Output A-G") + menu(menuFtype) + special(SPC_NOMOD) + prompt("Type of VALA") + initial("DOUBLE") + interest(1) + } + field(FTVB, DBF_MENU) { + prompt("Type of VALB") + initial("DOUBLE") + interest(1) + promptgroup("51 - Output A-G") + special(SPC_NOMOD) + menu(menuFtype) + } + field(FTVC, DBF_MENU) { + special(SPC_NOMOD) + menu(menuFtype) + promptgroup("51 - Output A-G") + interest(1) + prompt("Type of VALC") + initial("DOUBLE") + } + field(FTVD, DBF_MENU) { + interest(1) + prompt("Type of VALD") + initial("DOUBLE") + special(SPC_NOMOD) + menu(menuFtype) + promptgroup("51 - Output A-G") + } + field(FTVE, DBF_MENU) { + initial("DOUBLE") + prompt("Type of VALE") + interest(1) + promptgroup("51 - Output A-G") + special(SPC_NOMOD) + menu(menuFtype) + } + field(FTVF, DBF_MENU) { + prompt("Type of VALF") + initial("DOUBLE") + interest(1) + promptgroup("51 - Output A-G") + menu(menuFtype) + special(SPC_NOMOD) + } + field(FTVG, DBF_MENU) { + special(SPC_NOMOD) + menu(menuFtype) + promptgroup("51 - Output A-G") + interest(1) + initial("DOUBLE") + prompt("Type of VALG") + } + field(FTVH, DBF_MENU) { + initial("DOUBLE") + prompt("Type of VALH") + interest(1) + promptgroup("52 - Output H-N") + menu(menuFtype) + special(SPC_NOMOD) + } + field(FTVI, DBF_MENU) { + interest(1) + initial("DOUBLE") + prompt("Type of VALI") + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("52 - Output H-N") + } + field(FTVJ, DBF_MENU) { + promptgroup("52 - Output H-N") + menu(menuFtype) + special(SPC_NOMOD) + initial("DOUBLE") + prompt("Type of VALJ") + interest(1) + } + field(FTVK, DBF_MENU) { + prompt("Type of VALK") + initial("DOUBLE") + interest(1) + promptgroup("52 - Output H-N") + menu(menuFtype) + special(SPC_NOMOD) + } + field(FTVL, DBF_MENU) { + special(SPC_NOMOD) + menu(menuFtype) + promptgroup("52 - Output H-N") + interest(1) + initial("DOUBLE") + prompt("Type of VALL") + } + field(FTVM, DBF_MENU) { + interest(1) + prompt("Type of VALM") + initial("DOUBLE") + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("52 - Output H-N") + } + field(FTVN, DBF_MENU) { + initial("DOUBLE") + prompt("Type of VALN") + interest(1) + promptgroup("52 - Output H-N") + menu(menuFtype) + special(SPC_NOMOD) + } + field(FTVO, DBF_MENU) { + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("53 - Output O-U") + interest(1) + initial("DOUBLE") + prompt("Type of VALO") + } + field(FTVP, DBF_MENU) { + interest(1) + prompt("Type of VALP") + initial("DOUBLE") + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("53 - Output O-U") + } + field(FTVQ, DBF_MENU) { + promptgroup("53 - Output O-U") + menu(menuFtype) + special(SPC_NOMOD) + initial("DOUBLE") + prompt("Type of VALQ") + interest(1) + } + field(FTVR, DBF_MENU) { + interest(1) + prompt("Type of VALR") + initial("DOUBLE") + special(SPC_NOMOD) + menu(menuFtype) + promptgroup("53 - Output O-U") + } + field(FTVS, DBF_MENU) { + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("53 - Output O-U") + interest(1) + initial("DOUBLE") + prompt("Type of VALS") + } + field(FTVT, DBF_MENU) { + initial("DOUBLE") + prompt("Type of VALT") + interest(1) + promptgroup("53 - Output O-U") + special(SPC_NOMOD) + menu(menuFtype) + } + field(FTVU, DBF_MENU) { + initial("DOUBLE") + prompt("Type of VALU") + interest(1) + promptgroup("53 - Output O-U") + menu(menuFtype) + special(SPC_NOMOD) + } + field(NOVA, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + initial("1") + prompt("Max. elements in VALA") + promptgroup("51 - Output A-G") + } + field(NOVB, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + initial("1") + prompt("Max. elements in VALB") + promptgroup("51 - Output A-G") + } + field(NOVC, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + initial("1") + prompt("Max. elements in VALC") + promptgroup("51 - Output A-G") + } + field(NOVD, DBF_ULONG) { + prompt("Max. elements in VALD") + initial("1") + promptgroup("51 - Output A-G") + special(SPC_NOMOD) + interest(1) + } + field(NOVE, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + initial("1") + prompt("Max. elements in VALE") + promptgroup("51 - Output A-G") + } + field(NOVF, DBF_ULONG) { + promptgroup("51 - Output A-G") + prompt("Max. elements in VALF") + initial("1") + interest(1) + special(SPC_NOMOD) + } + field(NOVG, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + prompt("Max. elements in VALG") + initial("1") + promptgroup("51 - Output A-G") + } + field(NOVH, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + prompt("Max. elements in VAlH") + initial("1") + promptgroup("52 - Output H-N") + } + field(NOVI, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("52 - Output H-N") + prompt("Max. elements in VALI") + initial("1") + } + field(NOVJ, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("52 - Output H-N") + initial("1") + prompt("Max. elements in VALJ") + } + field(NOVK, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + initial("1") + prompt("Max. elements in VALK") + promptgroup("52 - Output H-N") + } + field(NOVL, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + prompt("Max. elements in VALL") + initial("1") + promptgroup("52 - Output H-N") + } + field(NOVM, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("52 - Output H-N") + prompt("Max. elements in VALM") + initial("1") + } + field(NOVN, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("52 - Output H-N") + prompt("Max. elements in VALN") + initial("1") + } + field(NOVO, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("53 - Output O-U") + prompt("Max. elements in VALO") + initial("1") + } + field(NOVP, DBF_ULONG) { + prompt("Max. elements in VALP") + initial("1") + promptgroup("53 - Output O-U") + special(SPC_NOMOD) + interest(1) + } + field(NOVQ, DBF_ULONG) { + prompt("Max. elements in VALQ") + initial("1") + promptgroup("53 - Output O-U") + special(SPC_NOMOD) + interest(1) + } + field(NOVR, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("53 - Output O-U") + initial("1") + prompt("Max. elements in VALR") + } + field(NOVS, DBF_ULONG) { + initial("1") + prompt("Max. elements in VALS") + promptgroup("53 - Output O-U") + special(SPC_NOMOD) + interest(1) + } + field(NOVT, DBF_ULONG) { + promptgroup("53 - Output O-U") + prompt("Max. elements in VALT") + initial("1") + interest(1) + special(SPC_NOMOD) + } + field(NOVU, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("53 - Output O-U") + prompt("Max. elements in VALU") + initial("1") + } + field(NEVA, DBF_ULONG) { + prompt("Num. elements in VALA") + initial("1") + interest(3) + special(SPC_NOMOD) + } + field(NEVB, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + prompt("Num. elements in VALB") + initial("1") + } + field(NEVC, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + prompt("Num. elements in VALC") + initial("1") + } + field(NEVD, DBF_ULONG) { + prompt("Num. elements in VALD") + initial("1") + interest(3) + special(SPC_NOMOD) + } + field(NEVE, DBF_ULONG) { + initial("1") + prompt("Num. elements in VALE") + interest(3) + special(SPC_NOMOD) + } + field(NEVF, DBF_ULONG) { + prompt("Num. elements in VALF") + initial("1") + interest(3) + special(SPC_NOMOD) + } + field(NEVG, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + prompt("Num. elements in VALG") + initial("1") + } + field(NEVH, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + prompt("Num. elements in VAlH") + initial("1") + } + field(NEVI, DBF_ULONG) { + initial("1") + prompt("Num. elements in VALI") + special(SPC_NOMOD) + interest(3) + } + field(NEVJ, DBF_ULONG) { + initial("1") + prompt("Num. elements in VALJ") + interest(3) + special(SPC_NOMOD) + } + field(NEVK, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + initial("1") + prompt("Num. elements in VALK") + } + field(NEVL, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + prompt("Num. elements in VALL") + initial("1") + } + field(NEVM, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + prompt("Num. elements in VALM") + initial("1") + } + field(NEVN, DBF_ULONG) { + prompt("Num. elements in VALN") + initial("1") + special(SPC_NOMOD) + interest(3) + } + field(NEVO, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + initial("1") + prompt("Num. elements in VALO") + } + field(NEVP, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + initial("1") + prompt("Num. elements in VALP") + } + field(NEVQ, DBF_ULONG) { + initial("1") + prompt("Num. elements in VALQ") + interest(3) + special(SPC_NOMOD) + } + field(NEVR, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + initial("1") + prompt("Num. elements in VALR") + } + field(NEVS, DBF_ULONG) { + initial("1") + prompt("Num. elements in VALS") + interest(3) + special(SPC_NOMOD) + } + field(NEVT, DBF_ULONG) { + prompt("Num. elements in VALT") + initial("1") + special(SPC_NOMOD) + interest(3) + } + field(NEVU, DBF_ULONG) { + interest(3) + special(SPC_NOMOD) + initial("1") + prompt("Num. elements in VALU") + } + field(ONVA, DBF_ULONG) { + interest(4) + special(SPC_NOMOD) + initial("1") + prompt("Num. elements in OVLA") + } + field(ONVB, DBF_ULONG) { + prompt("Num. elements in OVLB") + initial("1") + interest(4) + special(SPC_NOMOD) + } + field(ONVC, DBF_ULONG) { + prompt("Num. elements in OVLC") + initial("1") + special(SPC_NOMOD) + interest(4) + } + field(ONVD, DBF_ULONG) { + initial("1") + prompt("Num. elements in OVLD") + special(SPC_NOMOD) + interest(4) + } + field(ONVE, DBF_ULONG) { + special(SPC_NOMOD) + interest(4) + prompt("Num. elements in OVLE") + initial("1") + } + field(ONVF, DBF_ULONG) { + special(SPC_NOMOD) + interest(4) + prompt("Num. elements in OVLF") + initial("1") + } + field(ONVG, DBF_ULONG) { + initial("1") + prompt("Num. elements in OVLG") + special(SPC_NOMOD) + interest(4) + } + field(ONVH, DBF_ULONG) { + interest(4) + special(SPC_NOMOD) + prompt("Num. elements in VAlH") + initial("1") + } + field(ONVI, DBF_ULONG) { + prompt("Num. elements in OVLI") + initial("1") + special(SPC_NOMOD) + interest(4) + } + field(ONVJ, DBF_ULONG) { + special(SPC_NOMOD) + interest(4) + prompt("Num. elements in OVLJ") + initial("1") + } + field(ONVK, DBF_ULONG) { + prompt("Num. elements in OVLK") + initial("1") + interest(4) + special(SPC_NOMOD) + } + field(ONVL, DBF_ULONG) { + special(SPC_NOMOD) + interest(4) + initial("1") + prompt("Num. elements in OVLL") + } + field(ONVM, DBF_ULONG) { + special(SPC_NOMOD) + interest(4) + prompt("Num. elements in OVLM") + initial("1") + } + field(ONVN, DBF_ULONG) { + initial("1") + prompt("Num. elements in OVLN") + interest(4) + special(SPC_NOMOD) + } + field(ONVO, DBF_ULONG) { + special(SPC_NOMOD) + interest(4) + prompt("Num. elements in OVLO") + initial("1") + } + field(ONVP, DBF_ULONG) { + interest(4) + special(SPC_NOMOD) + initial("1") + prompt("Num. elements in OVLP") + } + field(ONVQ, DBF_ULONG) { + special(SPC_NOMOD) + interest(4) + prompt("Num. elements in OVLQ") + initial("1") + } + field(ONVR, DBF_ULONG) { + interest(4) + special(SPC_NOMOD) + initial("1") + prompt("Num. elements in OVLR") + } + field(ONVS, DBF_ULONG) { + interest(4) + special(SPC_NOMOD) + initial("1") + prompt("Num. elements in OVLS") + } + field(ONVT, DBF_ULONG) { + prompt("Num. elements in OVLT") + initial("1") + special(SPC_NOMOD) + interest(4) + } + field(ONVU, DBF_ULONG) { + prompt("Num. elements in OVLU") + initial("1") + special(SPC_NOMOD) + interest(4) + } +} +recordtype(fanout) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + special(SPC_NOMOD) + size(61) + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + prompt("Access Security Group") + promptgroup("10 - Common") + size(29) + special(SPC_AS) + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuScan) + interest(1) + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + interest(1) + special(SPC_SCAN) + size(40) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + prompt("Time Stamp Event") + promptgroup("20 - Scan") + } + field(TSEL, DBF_INLINK) { + interest(1) + prompt("Time Stamp Link") + promptgroup("20 - Scan") + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + pp(TRUE) + prompt("Force Processing") + interest(3) + } + field(STAT, DBF_MENU) { + initial("UDF") + prompt("Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(ACKT, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuYesNo) + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + } + field(DISS, DBF_MENU) { + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + special(SPC_NOMOD) + interest(2) + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + interest(1) + special(SPC_NOMOD) + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + } + field(SPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + interest(4) + special(SPC_NOMOD) + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + special(SPC_NOMOD) + interest(4) + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + menu(menuPriority) + special(SPC_SCAN) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + prompt("Break Point") + extra("char bkpt") + special(SPC_NOMOD) + interest(1) + } + field(UDF, DBF_UCHAR) { + interest(1) + prompt("Undefined") + initial("1") + pp(TRUE) + promptgroup("10 - Common") + } + field(UDFS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Undefined Alarm Sevrty") + initial("INVALID") + interest(1) + menu(menuAlarmSevr) + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Forward Process Link") + } + field(VAL, DBF_LONG) { + prompt("Used to trigger") + pp(TRUE) + asl(ASL0) + } + field(SELM, DBF_MENU) { + prompt("Select Mechanism") + promptgroup("30 - Action") + menu(fanoutSELM) + interest(1) + } + field(SELN, DBF_USHORT) { + interest(1) + initial("1") + prompt("Link Selection") + } + field(SELL, DBF_INLINK) { + interest(1) + promptgroup("30 - Action") + prompt("Link Selection Loc") + } + field(OFFS, DBF_SHORT) { + promptgroup("30 - Action") + initial("0") + prompt("Offset for Specified") + interest(1) + } + field(SHFT, DBF_SHORT) { + initial("-1") + prompt("Shift for Mask mode") + promptgroup("30 - Action") + interest(1) + } + field(LNK0, DBF_FWDLINK) { + interest(1) + prompt("Forward Link 0") + promptgroup("51 - Output 0-7") + } + field(LNK1, DBF_FWDLINK) { + interest(1) + prompt("Forward Link 1") + promptgroup("51 - Output 0-7") + } + field(LNK2, DBF_FWDLINK) { + interest(1) + prompt("Forward Link 2") + promptgroup("51 - Output 0-7") + } + field(LNK3, DBF_FWDLINK) { + interest(1) + prompt("Forward Link 3") + promptgroup("51 - Output 0-7") + } + field(LNK4, DBF_FWDLINK) { + promptgroup("51 - Output 0-7") + prompt("Forward Link 4") + interest(1) + } + field(LNK5, DBF_FWDLINK) { + interest(1) + promptgroup("51 - Output 0-7") + prompt("Forward Link 5") + } + field(LNK6, DBF_FWDLINK) { + interest(1) + promptgroup("51 - Output 0-7") + prompt("Forward Link 6") + } + field(LNK7, DBF_FWDLINK) { + promptgroup("51 - Output 0-7") + prompt("Forward Link 7") + interest(1) + } + field(LNK8, DBF_FWDLINK) { + promptgroup("52 - Output 8-F") + prompt("Forward Link 8") + interest(1) + } + field(LNK9, DBF_FWDLINK) { + interest(1) + prompt("Forward Link 9") + promptgroup("52 - Output 8-F") + } + field(LNKA, DBF_FWDLINK) { + promptgroup("52 - Output 8-F") + prompt("Forward Link 10") + interest(1) + } + field(LNKB, DBF_FWDLINK) { + interest(1) + prompt("Forward Link 11") + promptgroup("52 - Output 8-F") + } + field(LNKC, DBF_FWDLINK) { + promptgroup("52 - Output 8-F") + prompt("Forward Link 12") + interest(1) + } + field(LNKD, DBF_FWDLINK) { + prompt("Forward Link 13") + promptgroup("52 - Output 8-F") + interest(1) + } + field(LNKE, DBF_FWDLINK) { + prompt("Forward Link 14") + promptgroup("52 - Output 8-F") + interest(1) + } + field(LNKF, DBF_FWDLINK) { + promptgroup("52 - Output 8-F") + prompt("Forward Link 15") + interest(1) + } +} +recordtype(compress) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + size(61) + special(SPC_NOMOD) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + prompt("Descriptor") + promptgroup("10 - Common") + size(41) + } + field(ASG, DBF_STRING) { + size(29) + special(SPC_AS) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + menu(menuScan) + special(SPC_SCAN) + interest(1) + prompt("Scan Mechanism") + promptgroup("20 - Scan") + } + field(PINI, DBF_MENU) { + menu(menuPini) + interest(1) + prompt("Process at iocInit") + promptgroup("20 - Scan") + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + special(SPC_SCAN) + size(40) + interest(1) + prompt("Event Name") + promptgroup("20 - Scan") + } + field(TSE, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Time Stamp Event") + interest(1) + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + initial("1") + prompt("Disable Value") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Scanning Disable") + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + extra("ELLLIST mlis") + prompt("Monitor List") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + initial("UDF") + prompt("Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + interest(2) + special(SPC_NOMOD) + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + special(SPC_NOMOD) + interest(1) + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + prompt("pprocessNotify") + extra("struct processNotify *ppn") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + special(SPC_NOMOD) + interest(4) + } + field(RSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct typed_rset *rset") + prompt("Address of RSET") + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct dset *dset") + prompt("DSET address") + } + field(DPVT, DBF_NOACCESS) { + extra("void *dpvt") + prompt("Device Private") + interest(4) + special(SPC_NOMOD) + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + special(SPC_NOMOD) + interest(4) + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + special(SPC_NOMOD) + interest(4) + } + field(PRIO, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuPriority) + promptgroup("20 - Scan") + prompt("Scheduling Priority") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + prompt("Break Point") + extra("char bkpt") + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + initial("1") + pp(TRUE) + prompt("Undefined") + interest(1) + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_NOACCESS) { + pp(TRUE) + extra("void * val") + prompt("Value") + special(SPC_DBADDR) + asl(ASL0) + } + field(INP, DBF_INLINK) { + promptgroup("40 - Input") + prompt("Input Specification") + interest(1) + } + field(RES, DBF_SHORT) { + prompt("Reset") + special(SPC_RESET) + asl(ASL0) + interest(3) + } + field(ALG, DBF_MENU) { + prompt("Compression Algorithm") + promptgroup("30 - Action") + special(SPC_RESET) + menu(compressALG) + interest(1) + } + field(BALG, DBF_MENU) { + prompt("Buffering Algorithm") + promptgroup("30 - Action") + special(SPC_RESET) + menu(bufferingALG) + interest(1) + } + field(NSAM, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + prompt("Number of Values") + initial("1") + promptgroup("30 - Action") + } + field(N, DBF_ULONG) { + prompt("N to 1 Compression") + initial("1") + promptgroup("30 - Action") + special(SPC_RESET) + interest(1) + } + field(IHIL, DBF_DOUBLE) { + prompt("Init High Interest Lim") + promptgroup("30 - Action") + interest(1) + } + field(ILIL, DBF_DOUBLE) { + prompt("Init Low Interest Lim") + promptgroup("30 - Action") + interest(1) + } + field(HOPR, DBF_DOUBLE) { + interest(1) + prompt("High Operating Range") + promptgroup("80 - Display") + prop(YES) + } + field(LOPR, DBF_DOUBLE) { + interest(1) + prompt("Low Operating Range") + prop(YES) + promptgroup("80 - Display") + } + field(PREC, DBF_SHORT) { + interest(1) + prop(YES) + promptgroup("80 - Display") + prompt("Display Precision") + } + field(EGU, DBF_STRING) { + size(16) + interest(1) + prompt("Engineering Units") + prop(YES) + promptgroup("80 - Display") + } + field(OFF, DBF_ULONG) { + special(SPC_NOMOD) + prompt("Offset") + } + field(NUSE, DBF_ULONG) { + prompt("Number Used") + special(SPC_NOMOD) + } + field(OUSE, DBF_ULONG) { + prompt("Old Number Used") + special(SPC_NOMOD) + } + field(BPTR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Buffer Pointer") + extra("double *bptr") + } + field(SPTR, DBF_NOACCESS) { + extra("double *sptr") + prompt("Summing Buffer Ptr") + interest(4) + special(SPC_NOMOD) + } + field(WPTR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Working Buffer Ptr") + extra("double *wptr") + } + field(INPN, DBF_LONG) { + prompt("Number of elements in Working Buffer") + interest(4) + special(SPC_NOMOD) + } + field(CVB, DBF_DOUBLE) { + prompt("Compress Value Buffer") + special(SPC_NOMOD) + interest(3) + } + field(INX, DBF_ULONG) { + prompt("Compressed Array Inx") + interest(3) + special(SPC_NOMOD) + } +} +recordtype(calc) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "postfix.h" + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + size(29) + special(SPC_AS) + promptgroup("10 - Common") + prompt("Access Security Group") + } + field(SCAN, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuScan) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + prompt("Time Stamp Event") + promptgroup("20 - Scan") + } + field(TSEL, DBF_INLINK) { + interest(1) + prompt("Time Stamp Link") + promptgroup("20 - Scan") + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + prompt("Disable Value") + initial("1") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + prompt("Monitor lock") + extra("epicsMutexId mlok") + interest(4) + special(SPC_NOMOD) + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + interest(4) + special(SPC_NOMOD) + } + field(BKLNK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + prompt("Alarm Status") + initial("UDF") + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKT, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuYesNo) + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + interest(2) + special(SPC_NOMOD) + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + interest(1) + special(SPC_NOMOD) + } + field(PUTF, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + interest(1) + special(SPC_NOMOD) + } + field(ASP, DBF_NOACCESS) { + prompt("Access Security Pvt") + extra("struct asgMember *asp") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + interest(4) + special(SPC_NOMOD) + } + field(SPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct scan_element *spvt") + prompt("Scan Private") + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + extra("struct dset *dset") + prompt("DSET address") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + interest(4) + special(SPC_NOMOD) + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + special(SPC_SCAN) + menu(menuPriority) + interest(1) + prompt("Scheduling Priority") + promptgroup("20 - Scan") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + prompt("Undefined") + pp(TRUE) + initial("1") + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + } + field(TIME, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VAL, DBF_DOUBLE) { + promptgroup("50 - Output") + prompt("Result") + asl(ASL0) + } + field(CALC, DBF_STRING) { + special(SPC_CALC) + size(80) + promptgroup("30 - Action") + pp(TRUE) + initial("0") + prompt("Calculation") + } + field(INPA, DBF_INLINK) { + promptgroup("41 - Input A-F") + prompt("Input A") + interest(1) + } + field(INPB, DBF_INLINK) { + prompt("Input B") + promptgroup("41 - Input A-F") + interest(1) + } + field(INPC, DBF_INLINK) { + promptgroup("41 - Input A-F") + prompt("Input C") + interest(1) + } + field(INPD, DBF_INLINK) { + promptgroup("41 - Input A-F") + prompt("Input D") + interest(1) + } + field(INPE, DBF_INLINK) { + interest(1) + promptgroup("41 - Input A-F") + prompt("Input E") + } + field(INPF, DBF_INLINK) { + interest(1) + promptgroup("41 - Input A-F") + prompt("Input F") + } + field(INPG, DBF_INLINK) { + interest(1) + prompt("Input G") + promptgroup("42 - Input G-L") + } + field(INPH, DBF_INLINK) { + prompt("Input H") + promptgroup("42 - Input G-L") + interest(1) + } + field(INPI, DBF_INLINK) { + promptgroup("42 - Input G-L") + prompt("Input I") + interest(1) + } + field(INPJ, DBF_INLINK) { + promptgroup("42 - Input G-L") + prompt("Input J") + interest(1) + } + field(INPK, DBF_INLINK) { + prompt("Input K") + promptgroup("42 - Input G-L") + interest(1) + } + field(INPL, DBF_INLINK) { + interest(1) + promptgroup("42 - Input G-L") + prompt("Input L") + } + field(EGU, DBF_STRING) { + prompt("Engineering Units") + promptgroup("80 - Display") + prop(YES) + size(16) + interest(1) + } + field(PREC, DBF_SHORT) { + prop(YES) + promptgroup("80 - Display") + prompt("Display Precision") + interest(1) + } + field(HOPR, DBF_DOUBLE) { + prop(YES) + promptgroup("80 - Display") + prompt("High Operating Rng") + interest(1) + } + field(LOPR, DBF_DOUBLE) { + interest(1) + prompt("Low Operating Range") + prop(YES) + promptgroup("80 - Display") + } + field(HIHI, DBF_DOUBLE) { + interest(1) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Hihi Alarm Limit") + } + field(LOLO, DBF_DOUBLE) { + interest(1) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Lolo Alarm Limit") + } + field(HIGH, DBF_DOUBLE) { + interest(1) + pp(TRUE) + prompt("High Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + } + field(LOW, DBF_DOUBLE) { + interest(1) + prompt("Low Alarm Limit") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + } + field(HHSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("Hihi Severity") + promptgroup("70 - Alarm") + prop(YES) + } + field(LLSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Lolo Severity") + } + field(HSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("High Severity") + } + field(LSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Low Severity") + } + field(AFTC, DBF_DOUBLE) { + prompt("Alarm Filter Time Constant") + promptgroup("70 - Alarm") + interest(1) + } + field(AFVL, DBF_DOUBLE) { + prompt("Alarm Filter Value") + special(SPC_NOMOD) + interest(3) + } + field(HYST, DBF_DOUBLE) { + prompt("Alarm Deadband") + promptgroup("70 - Alarm") + interest(1) + } + field(ADEL, DBF_DOUBLE) { + interest(1) + prompt("Archive Deadband") + promptgroup("80 - Display") + } + field(MDEL, DBF_DOUBLE) { + interest(1) + promptgroup("80 - Display") + prompt("Monitor Deadband") + } + field(A, DBF_DOUBLE) { + prompt("Value of Input A") + pp(TRUE) + } + field(B, DBF_DOUBLE) { + prompt("Value of Input B") + pp(TRUE) + } + field(C, DBF_DOUBLE) { + prompt("Value of Input C") + pp(TRUE) + } + field(D, DBF_DOUBLE) { + prompt("Value of Input D") + pp(TRUE) + } + field(E, DBF_DOUBLE) { + prompt("Value of Input E") + pp(TRUE) + } + field(F, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input F") + } + field(G, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input G") + } + field(H, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input H") + } + field(I, DBF_DOUBLE) { + prompt("Value of Input I") + pp(TRUE) + } + field(J, DBF_DOUBLE) { + prompt("Value of Input J") + pp(TRUE) + } + field(K, DBF_DOUBLE) { + prompt("Value of Input K") + pp(TRUE) + } + field(L, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input L") + } + field(LA, DBF_DOUBLE) { + prompt("Prev Value of A") + interest(3) + special(SPC_NOMOD) + } + field(LB, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of B") + } + field(LC, DBF_DOUBLE) { + prompt("Prev Value of C") + special(SPC_NOMOD) + interest(3) + } + field(LD, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of D") + } + field(LE, DBF_DOUBLE) { + prompt("Prev Value of E") + special(SPC_NOMOD) + interest(3) + } + field(LF, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of F") + } + field(LG, DBF_DOUBLE) { + prompt("Prev Value of G") + special(SPC_NOMOD) + interest(3) + } + field(LH, DBF_DOUBLE) { + prompt("Prev Value of H") + special(SPC_NOMOD) + interest(3) + } + field(LI, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of I") + } + field(LJ, DBF_DOUBLE) { + prompt("Prev Value of J") + special(SPC_NOMOD) + interest(3) + } + field(LK, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of K") + } + field(LL, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of L") + } + field(LALM, DBF_DOUBLE) { + prompt("Last Value Alarmed") + interest(3) + special(SPC_NOMOD) + } + field(ALST, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Archived") + } + field(MLST, DBF_DOUBLE) { + prompt("Last Val Monitored") + special(SPC_NOMOD) + interest(3) + } + field(RPCL, DBF_NOACCESS) { + extra("char rpcl[INFIX_TO_POSTFIX_SIZE(80)]") + prompt("Reverse Polish Calc") + special(SPC_NOMOD) + interest(4) + } +} +recordtype(mbbo) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + size(61) + special(SPC_NOMOD) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + size(41) + prompt("Descriptor") + promptgroup("10 - Common") + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + menu(menuScan) + special(SPC_SCAN) + interest(1) + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + prompt("Event Name") + promptgroup("20 - Scan") + size(40) + special(SPC_SCAN) + interest(1) + } + field(TSE, DBF_SHORT) { + prompt("Time Stamp Event") + promptgroup("20 - Scan") + interest(1) + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + special(SPC_NOMOD) + interest(4) + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + interest(4) + special(SPC_NOMOD) + } + field(BKLNK, DBF_NOACCESS) { + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + prompt("Force Processing") + pp(TRUE) + } + field(STAT, DBF_MENU) { + initial("UDF") + prompt("Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKS, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + prompt("Alarm Ack Transient") + initial("YES") + promptgroup("70 - Alarm") + special(SPC_NOMOD) + menu(menuYesNo) + interest(2) + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(2) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + interest(1) + special(SPC_NOMOD) + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + interest(1) + special(SPC_NOMOD) + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + interest(1) + special(SPC_NOMOD) + } + field(ASP, DBF_NOACCESS) { + prompt("Access Security Pvt") + extra("struct asgMember *asp") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + extra("struct processNotify *ppn") + prompt("pprocessNotify") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + special(SPC_NOMOD) + interest(4) + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of RSET") + extra("struct typed_rset *rset") + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + extra("void *dpvt") + prompt("Device Private") + interest(4) + special(SPC_NOMOD) + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + menu(menuPriority) + special(SPC_SCAN) + interest(1) + prompt("Scheduling Priority") + promptgroup("20 - Scan") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + prompt("Break Point") + extra("char bkpt") + special(SPC_NOMOD) + interest(1) + } + field(UDF, DBF_UCHAR) { + prompt("Undefined") + pp(TRUE) + initial("1") + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VAL, DBF_ENUM) { + promptgroup("50 - Output") + pp(TRUE) + prompt("Desired Value") + asl(ASL0) + special(SPC_DBADDR) + } + field(DOL, DBF_INLINK) { + promptgroup("40 - Input") + prompt("Desired Output Loc") + interest(1) + } + field(OMSL, DBF_MENU) { + prompt("Output Mode Select") + promptgroup("50 - Output") + menu(menuOmsl) + interest(1) + } + field(NOBT, DBF_USHORT) { + promptgroup("50 - Output") + prompt("Number of Bits") + interest(1) + special(SPC_NOMOD) + } + field(OUT, DBF_OUTLINK) { + promptgroup("50 - Output") + prompt("Output Specification") + interest(1) + } + field(ZRVL, DBF_ULONG) { + prompt("Zero Value") + pp(TRUE) + interest(1) + base(HEX) + promptgroup("51 - Output 0-7") + special(SPC_MOD) + } + field(ONVL, DBF_ULONG) { + interest(1) + base(HEX) + pp(TRUE) + prompt("One Value") + special(SPC_MOD) + promptgroup("51 - Output 0-7") + } + field(TWVL, DBF_ULONG) { + special(SPC_MOD) + promptgroup("51 - Output 0-7") + base(HEX) + interest(1) + pp(TRUE) + prompt("Two Value") + } + field(THVL, DBF_ULONG) { + promptgroup("51 - Output 0-7") + special(SPC_MOD) + prompt("Three Value") + pp(TRUE) + interest(1) + base(HEX) + } + field(FRVL, DBF_ULONG) { + promptgroup("51 - Output 0-7") + special(SPC_MOD) + pp(TRUE) + prompt("Four Value") + base(HEX) + interest(1) + } + field(FVVL, DBF_ULONG) { + prompt("Five Value") + pp(TRUE) + interest(1) + base(HEX) + promptgroup("51 - Output 0-7") + special(SPC_MOD) + } + field(SXVL, DBF_ULONG) { + promptgroup("51 - Output 0-7") + special(SPC_MOD) + pp(TRUE) + prompt("Six Value") + base(HEX) + interest(1) + } + field(SVVL, DBF_ULONG) { + base(HEX) + interest(1) + prompt("Seven Value") + pp(TRUE) + special(SPC_MOD) + promptgroup("51 - Output 0-7") + } + field(EIVL, DBF_ULONG) { + promptgroup("52 - Output 8-15") + special(SPC_MOD) + pp(TRUE) + prompt("Eight Value") + base(HEX) + interest(1) + } + field(NIVL, DBF_ULONG) { + promptgroup("52 - Output 8-15") + special(SPC_MOD) + prompt("Nine Value") + pp(TRUE) + interest(1) + base(HEX) + } + field(TEVL, DBF_ULONG) { + promptgroup("52 - Output 8-15") + special(SPC_MOD) + pp(TRUE) + prompt("Ten Value") + base(HEX) + interest(1) + } + field(ELVL, DBF_ULONG) { + promptgroup("52 - Output 8-15") + special(SPC_MOD) + pp(TRUE) + prompt("Eleven Value") + interest(1) + base(HEX) + } + field(TVVL, DBF_ULONG) { + pp(TRUE) + prompt("Twelve Value") + interest(1) + base(HEX) + promptgroup("52 - Output 8-15") + special(SPC_MOD) + } + field(TTVL, DBF_ULONG) { + pp(TRUE) + prompt("Thirteen Value") + base(HEX) + interest(1) + promptgroup("52 - Output 8-15") + special(SPC_MOD) + } + field(FTVL, DBF_ULONG) { + special(SPC_MOD) + promptgroup("52 - Output 8-15") + interest(1) + base(HEX) + pp(TRUE) + prompt("Fourteen Value") + } + field(FFVL, DBF_ULONG) { + special(SPC_MOD) + promptgroup("52 - Output 8-15") + interest(1) + base(HEX) + prompt("Fifteen Value") + pp(TRUE) + } + field(ZRST, DBF_STRING) { + promptgroup("81 - Display 0-7") + special(SPC_MOD) + size(26) + pp(TRUE) + prompt("Zero String") + interest(1) + } + field(ONST, DBF_STRING) { + prompt("One String") + pp(TRUE) + interest(1) + promptgroup("81 - Display 0-7") + special(SPC_MOD) + size(26) + } + field(TWST, DBF_STRING) { + prompt("Two String") + pp(TRUE) + interest(1) + promptgroup("81 - Display 0-7") + special(SPC_MOD) + size(26) + } + field(THST, DBF_STRING) { + promptgroup("81 - Display 0-7") + special(SPC_MOD) + size(26) + pp(TRUE) + prompt("Three String") + interest(1) + } + field(FRST, DBF_STRING) { + special(SPC_MOD) + size(26) + promptgroup("81 - Display 0-7") + interest(1) + prompt("Four String") + pp(TRUE) + } + field(FVST, DBF_STRING) { + special(SPC_MOD) + size(26) + promptgroup("81 - Display 0-7") + interest(1) + pp(TRUE) + prompt("Five String") + } + field(SXST, DBF_STRING) { + interest(1) + prompt("Six String") + pp(TRUE) + special(SPC_MOD) + size(26) + promptgroup("81 - Display 0-7") + } + field(SVST, DBF_STRING) { + promptgroup("81 - Display 0-7") + special(SPC_MOD) + size(26) + pp(TRUE) + prompt("Seven String") + interest(1) + } + field(EIST, DBF_STRING) { + interest(1) + pp(TRUE) + prompt("Eight String") + special(SPC_MOD) + size(26) + promptgroup("82 - Display 8-15") + } + field(NIST, DBF_STRING) { + interest(1) + prompt("Nine String") + pp(TRUE) + special(SPC_MOD) + size(26) + promptgroup("82 - Display 8-15") + } + field(TEST, DBF_STRING) { + promptgroup("82 - Display 8-15") + special(SPC_MOD) + size(26) + pp(TRUE) + prompt("Ten String") + interest(1) + } + field(ELST, DBF_STRING) { + size(26) + special(SPC_MOD) + promptgroup("82 - Display 8-15") + interest(1) + pp(TRUE) + prompt("Eleven String") + } + field(TVST, DBF_STRING) { + prompt("Twelve String") + pp(TRUE) + interest(1) + promptgroup("82 - Display 8-15") + special(SPC_MOD) + size(26) + } + field(TTST, DBF_STRING) { + pp(TRUE) + prompt("Thirteen String") + interest(1) + promptgroup("82 - Display 8-15") + special(SPC_MOD) + size(26) + } + field(FTST, DBF_STRING) { + prompt("Fourteen String") + pp(TRUE) + interest(1) + promptgroup("82 - Display 8-15") + size(26) + special(SPC_MOD) + } + field(FFST, DBF_STRING) { + promptgroup("82 - Display 8-15") + size(26) + special(SPC_MOD) + pp(TRUE) + prompt("Fifteen String") + interest(1) + } + field(ZRSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("71 - Alarm 0-7") + prompt("State Zero Severity") + pp(TRUE) + } + field(ONSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("71 - Alarm 0-7") + prompt("State One Severity") + pp(TRUE) + } + field(TWSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("State Two Severity") + promptgroup("71 - Alarm 0-7") + } + field(THSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("71 - Alarm 0-7") + prompt("State Three Severity") + pp(TRUE) + } + field(FRSV, DBF_MENU) { + prompt("State Four Severity") + pp(TRUE) + promptgroup("71 - Alarm 0-7") + menu(menuAlarmSevr) + interest(1) + } + field(FVSV, DBF_MENU) { + promptgroup("71 - Alarm 0-7") + prompt("State Five Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(SXSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("State Six Severity") + promptgroup("71 - Alarm 0-7") + } + field(SVSV, DBF_MENU) { + promptgroup("71 - Alarm 0-7") + pp(TRUE) + prompt("State Seven Severity") + interest(1) + menu(menuAlarmSevr) + } + field(EISV, DBF_MENU) { + promptgroup("72 - Alarm 8-15") + pp(TRUE) + prompt("State Eight Severity") + interest(1) + menu(menuAlarmSevr) + } + field(NISV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("State Nine Severity") + promptgroup("72 - Alarm 8-15") + } + field(TESV, DBF_MENU) { + promptgroup("72 - Alarm 8-15") + prompt("State Ten Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(ELSV, DBF_MENU) { + promptgroup("72 - Alarm 8-15") + pp(TRUE) + prompt("State Eleven Severity") + interest(1) + menu(menuAlarmSevr) + } + field(TVSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("72 - Alarm 8-15") + prompt("State Twelve Severity") + pp(TRUE) + } + field(TTSV, DBF_MENU) { + promptgroup("72 - Alarm 8-15") + prompt("State Thirteen Sevr") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(FTSV, DBF_MENU) { + prompt("State Fourteen Sevr") + pp(TRUE) + promptgroup("72 - Alarm 8-15") + menu(menuAlarmSevr) + interest(1) + } + field(FFSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("72 - Alarm 8-15") + prompt("State Fifteen Sevr") + pp(TRUE) + } + field(UNSV, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Unknown State Sevr") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(COSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + pp(TRUE) + prompt("Change of State Sevr") + } + field(RVAL, DBF_ULONG) { + pp(TRUE) + prompt("Raw Value") + } + field(ORAW, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Raw Value") + } + field(RBV, DBF_ULONG) { + prompt("Readback Value") + special(SPC_NOMOD) + } + field(ORBV, DBF_ULONG) { + prompt("Prev Readback Value") + special(SPC_NOMOD) + interest(3) + } + field(MASK, DBF_ULONG) { + prompt("Hardware Mask") + special(SPC_NOMOD) + interest(1) + } + field(MLST, DBF_USHORT) { + interest(3) + special(SPC_NOMOD) + prompt("Last Value Monitored") + } + field(LALM, DBF_USHORT) { + prompt("Last Value Alarmed") + interest(3) + special(SPC_NOMOD) + } + field(SDEF, DBF_SHORT) { + interest(3) + special(SPC_NOMOD) + prompt("States Defined") + } + field(SHFT, DBF_USHORT) { + prompt("Shift") + promptgroup("50 - Output") + interest(1) + } + field(SIOL, DBF_OUTLINK) { + interest(1) + prompt("Simulation Output Link") + promptgroup("90 - Simulate") + } + field(SIML, DBF_INLINK) { + interest(1) + prompt("Simulation Mode Link") + promptgroup("90 - Simulate") + } + field(SIMM, DBF_MENU) { + interest(1) + special(SPC_MOD) + menu(menuYesNo) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + prompt("Simulation Mode Severity") + promptgroup("90 - Simulate") + menu(menuAlarmSevr) + interest(2) + } + field(OLDSIMM, DBF_MENU) { + interest(4) + special(SPC_NOMOD) + menu(menuSimm) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + promptgroup("90 - Simulate") + initial("65535") + prompt("Sim. Mode Scan") + interest(1) + menu(menuScan) + } + field(SDLY, DBF_DOUBLE) { + interest(2) + promptgroup("90 - Simulate") + initial("-1.0") + prompt("Sim. Mode Async Delay") + } + field(SIMPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + } + field(IVOA, DBF_MENU) { + interest(2) + menu(menuIvoa) + promptgroup("50 - Output") + prompt("INVALID outpt action") + } + field(IVOV, DBF_USHORT) { + interest(2) + promptgroup("50 - Output") + prompt("INVALID output value") + } +} +device(mbbo, CONSTANT, devMbboSoft, "Soft Channel") +device(mbbo, CONSTANT, devMbboSoftRaw, "Raw Soft Channel") +device(mbbo, CONSTANT, devMbboSoftCallback, "Async Soft Channel") +device(mbbo, INST_IO, asynMbboInt32, "asynInt32") +device(mbbo, INST_IO, asynMbboUInt32Digital, "asynUInt32Digital") +recordtype(state) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + size(29) + special(SPC_AS) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + menu(menuScan) + special(SPC_SCAN) + interest(1) + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + special(SPC_SCAN) + interest(1) + prompt("Scan Phase") + promptgroup("20 - Scan") + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + prompt("Device Type") + promptgroup("10 - Common") + interest(1) + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + initial("1") + prompt("Disable Value") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + pp(TRUE) + prompt("Force Processing") + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + menu(menuAlarmStat) + special(SPC_NOMOD) + interest(2) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + } + field(ACKS, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + promptgroup("70 - Alarm") + initial("YES") + prompt("Alarm Ack Transient") + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + } + field(DISS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + prompt("Access Security Pvt") + extra("struct asgMember *asp") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + prompt("pprocessNotify") + extra("struct processNotify *ppn") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + special(SPC_NOMOD) + interest(4) + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + special(SPC_NOMOD) + interest(4) + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + special(SPC_NOMOD) + interest(4) + } + field(PRIO, DBF_MENU) { + prompt("Scheduling Priority") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuPriority) + interest(1) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + extra("char bkpt") + prompt("Break Point") + interest(1) + special(SPC_NOMOD) + } + field(UDF, DBF_UCHAR) { + prompt("Undefined") + initial("1") + pp(TRUE) + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VAL, DBF_STRING) { + promptgroup("40 - Input") + prompt("Value") + pp(TRUE) + asl(ASL0) + size(20) + } + field(OVAL, DBF_STRING) { + special(SPC_NOMOD) + size(20) + interest(3) + prompt("Prev Value") + } +} +recordtype(bi) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + special(SPC_NOMOD) + size(61) + } + field(DESC, DBF_STRING) { + prompt("Descriptor") + promptgroup("10 - Common") + size(41) + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + special(SPC_AS) + size(29) + } + field(SCAN, DBF_MENU) { + interest(1) + menu(menuScan) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + menu(menuPini) + interest(1) + prompt("Process at iocInit") + promptgroup("20 - Scan") + } + field(PHAS, DBF_SHORT) { + prompt("Scan Phase") + promptgroup("20 - Scan") + special(SPC_SCAN) + interest(1) + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + interest(1) + prompt("Time Stamp Link") + promptgroup("20 - Scan") + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor lock") + extra("epicsMutexId mlok") + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + prompt("Alarm Status") + initial("UDF") + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(NSEV, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + } + field(ACKT, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + } + field(DISS, DBF_MENU) { + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + interest(1) + special(SPC_NOMOD) + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + special(SPC_NOMOD) + interest(4) + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + prompt("Address of RSET") + extra("struct typed_rset *rset") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + extra("struct dset *dset") + prompt("DSET address") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + interest(4) + special(SPC_NOMOD) + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + } + field(LSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + interest(1) + menu(menuPriority) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scheduling Priority") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + prompt("Break Point") + extra("char bkpt") + special(SPC_NOMOD) + interest(1) + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + prompt("Undefined") + pp(TRUE) + initial("1") + interest(1) + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(INP, DBF_INLINK) { + prompt("Input Specification") + promptgroup("40 - Input") + interest(1) + } + field(VAL, DBF_ENUM) { + promptgroup("40 - Input") + pp(TRUE) + prompt("Current Value") + asl(ASL0) + } + field(ZSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("Zero Error Severity") + promptgroup("70 - Alarm") + } + field(OSV, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("One Error Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(COSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + pp(TRUE) + prompt("Change of State Svr") + } + field(ZNAM, DBF_STRING) { + interest(1) + size(26) + promptgroup("80 - Display") + prop(YES) + pp(TRUE) + prompt("Zero Name") + } + field(ONAM, DBF_STRING) { + size(26) + interest(1) + pp(TRUE) + prompt("One Name") + promptgroup("80 - Display") + prop(YES) + } + field(RVAL, DBF_ULONG) { + pp(TRUE) + prompt("Raw Value") + } + field(ORAW, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + prompt("prev Raw Value") + } + field(MASK, DBF_ULONG) { + prompt("Hardware Mask") + interest(1) + special(SPC_NOMOD) + } + field(LALM, DBF_USHORT) { + prompt("Last Value Alarmed") + interest(3) + special(SPC_NOMOD) + } + field(MLST, DBF_USHORT) { + prompt("Last Value Monitored") + special(SPC_NOMOD) + interest(3) + } + field(SIOL, DBF_INLINK) { + prompt("Simulation Input Link") + promptgroup("90 - Simulate") + interest(1) + } + field(SVAL, DBF_ULONG) { + prompt("Simulation Value") + } + field(SIML, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + interest(1) + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + interest(1) + menu(menuSimm) + special(SPC_MOD) + } + field(SIMS, DBF_MENU) { + prompt("Simulation Mode Severity") + promptgroup("90 - Simulate") + menu(menuAlarmSevr) + interest(2) + } + field(OLDSIMM, DBF_MENU) { + prompt("Prev. Simulation Mode") + special(SPC_NOMOD) + menu(menuSimm) + interest(4) + } + field(SSCN, DBF_MENU) { + menu(menuScan) + interest(1) + initial("65535") + prompt("Sim. Mode Scan") + promptgroup("90 - Simulate") + } + field(SDLY, DBF_DOUBLE) { + prompt("Sim. Mode Async Delay") + initial("-1.0") + promptgroup("90 - Simulate") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + } +} +device(bi, CONSTANT, devBiSoft, "Soft Channel") +device(bi, CONSTANT, devBiSoftRaw, "Raw Soft Channel") +device(bi, CONSTANT, devBiSoftCallback, "Async Soft Channel") +device(bi, INST_IO, devBiDbState, "Db State") +device(bi, INST_IO, asynBiInt32, "asynInt32") +device(bi, INST_IO, asynBiUInt32Digital, "asynUInt32Digital") +recordtype(int64out) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + size(61) + special(SPC_NOMOD) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + promptgroup("10 - Common") + prompt("Descriptor") + size(41) + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuScan) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + special(SPC_SCAN) + interest(1) + prompt("Scan Phase") + promptgroup("20 - Scan") + } + field(EVNT, DBF_STRING) { + prompt("Event Name") + promptgroup("20 - Scan") + special(SPC_SCAN) + size(40) + interest(1) + } + field(TSE, DBF_SHORT) { + interest(1) + prompt("Time Stamp Event") + promptgroup("20 - Scan") + } + field(TSEL, DBF_INLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Link") + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + interest(4) + special(SPC_NOMOD) + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + interest(4) + special(SPC_NOMOD) + } + field(BKLNK, DBF_NOACCESS) { + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + } + field(DISS, DBF_MENU) { + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + interest(2) + special(SPC_NOMOD) + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + special(SPC_NOMOD) + interest(1) + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + special(SPC_NOMOD) + interest(1) + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + prompt("pprocessNotify") + extra("struct processNotify *ppn") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + interest(4) + special(SPC_NOMOD) + } + field(SPVT, DBF_NOACCESS) { + prompt("Scan Private") + extra("struct scan_element *spvt") + special(SPC_NOMOD) + interest(4) + } + field(RSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct typed_rset *rset") + prompt("Address of RSET") + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + interest(4) + special(SPC_NOMOD) + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + } + field(LSET, DBF_NOACCESS) { + extra("struct lockRecord *lset") + prompt("Lock Set") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuPriority) + promptgroup("20 - Scan") + prompt("Scheduling Priority") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + prompt("Break Point") + extra("char bkpt") + } + field(UDF, DBF_UCHAR) { + interest(1) + promptgroup("10 - Common") + prompt("Undefined") + initial("1") + pp(TRUE) + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Undefined Alarm Sevrty") + initial("INVALID") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + extra("epicsTimeStamp time") + prompt("Time") + special(SPC_NOMOD) + interest(2) + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_INT64) { + asl(ASL0) + promptgroup("50 - Output") + pp(TRUE) + prompt("Desired Output") + } + field(OUT, DBF_OUTLINK) { + promptgroup("50 - Output") + prompt("Output Specification") + interest(1) + } + field(DOL, DBF_INLINK) { + interest(1) + prompt("Desired Output Loc") + promptgroup("40 - Input") + } + field(OMSL, DBF_MENU) { + menu(menuOmsl) + interest(1) + prompt("Output Mode Select") + promptgroup("50 - Output") + } + field(EGU, DBF_STRING) { + prompt("Units name") + prop(YES) + promptgroup("80 - Display") + size(16) + interest(1) + } + field(DRVH, DBF_INT64) { + interest(1) + prompt("Drive High Limit") + pp(TRUE) + prop(YES) + promptgroup("30 - Action") + } + field(DRVL, DBF_INT64) { + prop(YES) + promptgroup("30 - Action") + prompt("Drive Low Limit") + pp(TRUE) + interest(1) + } + field(HOPR, DBF_INT64) { + interest(1) + prop(YES) + promptgroup("80 - Display") + prompt("High Operating Range") + } + field(LOPR, DBF_INT64) { + interest(1) + promptgroup("80 - Display") + prop(YES) + prompt("Low Operating Range") + } + field(HIHI, DBF_INT64) { + prompt("Hihi Alarm Limit") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + interest(1) + } + field(LOLO, DBF_INT64) { + interest(1) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Lolo Alarm Limit") + } + field(HIGH, DBF_INT64) { + pp(TRUE) + prompt("High Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + interest(1) + } + field(LOW, DBF_INT64) { + prompt("Low Alarm Limit") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + interest(1) + } + field(HHSV, DBF_MENU) { + pp(TRUE) + prompt("Hihi Severity") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LLSV, DBF_MENU) { + pp(TRUE) + prompt("Lolo Severity") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(HSV, DBF_MENU) { + prompt("High Severity") + pp(TRUE) + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Low Severity") + pp(TRUE) + } + field(HYST, DBF_INT64) { + interest(1) + prompt("Alarm Deadband") + promptgroup("70 - Alarm") + } + field(ADEL, DBF_INT64) { + interest(1) + promptgroup("80 - Display") + prompt("Archive Deadband") + } + field(MDEL, DBF_INT64) { + prompt("Monitor Deadband") + promptgroup("80 - Display") + interest(1) + } + field(LALM, DBF_INT64) { + prompt("Last Value Alarmed") + interest(3) + special(SPC_NOMOD) + } + field(ALST, DBF_INT64) { + interest(3) + special(SPC_NOMOD) + prompt("Last Value Archived") + } + field(MLST, DBF_INT64) { + special(SPC_NOMOD) + interest(3) + prompt("Last Val Monitored") + } + field(SIOL, DBF_OUTLINK) { + prompt("Simulation Output Link") + promptgroup("90 - Simulate") + interest(1) + } + field(SIML, DBF_INLINK) { + interest(1) + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + } + field(SIMM, DBF_MENU) { + menu(menuYesNo) + special(SPC_MOD) + interest(1) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + menu(menuAlarmSevr) + interest(2) + prompt("Simulation Mode Severity") + promptgroup("90 - Simulate") + } + field(OLDSIMM, DBF_MENU) { + interest(4) + special(SPC_NOMOD) + menu(menuSimm) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + promptgroup("90 - Simulate") + prompt("Sim. Mode Scan") + initial("65535") + interest(1) + menu(menuScan) + } + field(SDLY, DBF_DOUBLE) { + promptgroup("90 - Simulate") + initial("-1.0") + prompt("Sim. Mode Async Delay") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Sim. Mode Private") + extra("epicsCallback *simpvt") + } + field(IVOA, DBF_MENU) { + menu(menuIvoa) + interest(2) + prompt("INVALID output action") + promptgroup("50 - Output") + } + field(IVOV, DBF_INT64) { + interest(2) + prompt("INVALID output value") + promptgroup("50 - Output") + } +} +device(int64out, CONSTANT, devI64outSoft, "Soft Channel") +device(int64out, CONSTANT, devI64outSoftCallback, "Async Soft Channel") +device(int64out, INST_IO, asynInt64Out, "asynInt64") +recordtype(stringin) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuScan) + interest(1) + } + field(PINI, DBF_MENU) { + interest(1) + menu(menuPini) + promptgroup("20 - Scan") + prompt("Process at iocInit") + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + special(SPC_SCAN) + size(40) + interest(1) + prompt("Event Name") + promptgroup("20 - Scan") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor List") + extra("ELLLIST mlis") + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + pp(TRUE) + prompt("Force Processing") + } + field(STAT, DBF_MENU) { + initial("UDF") + prompt("Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + } + field(NSEV, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + promptgroup("70 - Alarm") + initial("YES") + prompt("Alarm Ack Transient") + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + interest(1) + special(SPC_NOMOD) + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + } + field(SPVT, DBF_NOACCESS) { + prompt("Scan Private") + extra("struct scan_element *spvt") + interest(4) + special(SPC_NOMOD) + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + special(SPC_NOMOD) + interest(4) + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct dset *dset") + prompt("DSET address") + } + field(DPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("void *dpvt") + prompt("Device Private") + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + special(SPC_NOMOD) + interest(4) + } + field(LSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + interest(1) + menu(menuPriority) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scheduling Priority") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + prompt("Break Point") + extra("char bkpt") + special(SPC_NOMOD) + interest(1) + } + field(UDF, DBF_UCHAR) { + initial("1") + pp(TRUE) + prompt("Undefined") + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VAL, DBF_STRING) { + asl(ASL0) + size(40) + promptgroup("40 - Input") + prompt("Current Value") + pp(TRUE) + } + field(OVAL, DBF_STRING) { + prompt("Previous Value") + interest(3) + special(SPC_NOMOD) + size(40) + } + field(INP, DBF_INLINK) { + promptgroup("40 - Input") + prompt("Input Specification") + interest(1) + } + field(MPST, DBF_MENU) { + menu(stringinPOST) + interest(1) + prompt("Post Value Monitors") + promptgroup("80 - Display") + } + field(APST, DBF_MENU) { + prompt("Post Archive Monitors") + promptgroup("80 - Display") + menu(stringinPOST) + interest(1) + } + field(SIOL, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Input Link") + interest(1) + } + field(SVAL, DBF_STRING) { + size(40) + pp(TRUE) + prompt("Simulation Value") + } + field(SIML, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + interest(1) + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + interest(1) + special(SPC_MOD) + menu(menuYesNo) + } + field(SIMS, DBF_MENU) { + prompt("Simulation Mode Severity") + promptgroup("90 - Simulate") + menu(menuAlarmSevr) + interest(2) + } + field(OLDSIMM, DBF_MENU) { + interest(4) + special(SPC_NOMOD) + menu(menuSimm) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + interest(1) + menu(menuScan) + promptgroup("90 - Simulate") + prompt("Sim. Mode Scan") + initial("65535") + } + field(SDLY, DBF_DOUBLE) { + initial("-1.0") + prompt("Sim. Mode Async Delay") + promptgroup("90 - Simulate") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + interest(4) + special(SPC_NOMOD) + } +} +device(stringin, CONSTANT, devSiSoft, "Soft Channel") +device(stringin, CONSTANT, devSiSoftCallback, "Async Soft Channel") +device(stringin, INST_IO, devTimestampSI, "Soft Timestamp") +device(stringin, INST_IO, devSiGeneralTime, "General Time") +device(stringin, INST_IO, devSiEnviron, "getenv") +device(stringin, INST_IO, asynSiOctetCmdResponse, "asynOctetCmdResponse") +device(stringin, INST_IO, asynSiOctetWriteRead, "asynOctetWriteRead") +device(stringin, INST_IO, asynSiOctetRead, "asynOctetRead") +recordtype(aao) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + promptgroup("10 - Common") + prompt("Access Security Group") + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + menu(menuScan) + special(SPC_SCAN) + interest(1) + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + promptgroup("20 - Scan") + prompt("Event Name") + interest(1) + size(40) + special(SPC_SCAN) + } + field(TSE, DBF_SHORT) { + prompt("Time Stamp Event") + promptgroup("20 - Scan") + interest(1) + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + prompt("Monitor lock") + extra("epicsMutexId mlok") + interest(4) + special(SPC_NOMOD) + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + pp(TRUE) + prompt("Force Processing") + interest(3) + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + prompt("Alarm Status") + initial("UDF") + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + interest(2) + special(SPC_NOMOD) + menu(menuYesNo) + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + interest(1) + special(SPC_NOMOD) + } + field(RPRO, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + extra("struct processNotify *ppn") + prompt("pprocessNotify") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + special(SPC_NOMOD) + interest(4) + } + field(SPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct typed_rset *rset") + prompt("Address of RSET") + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + extra("void *dpvt") + prompt("Device Private") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + special(SPC_SCAN) + menu(menuPriority) + interest(1) + prompt("Scheduling Priority") + promptgroup("20 - Scan") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + extra("char bkpt") + prompt("Break Point") + special(SPC_NOMOD) + interest(1) + } + field(UDF, DBF_UCHAR) { + interest(1) + promptgroup("10 - Common") + prompt("Undefined") + pp(TRUE) + initial("1") + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + } + field(TIME, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VAL, DBF_NOACCESS) { + pp(TRUE) + extra("void * val") + prompt("Value") + special(SPC_DBADDR) + asl(ASL0) + } + field(PREC, DBF_SHORT) { + prompt("Display Precision") + prop(YES) + promptgroup("80 - Display") + interest(1) + } + field(OUT, DBF_OUTLINK) { + promptgroup("50 - Output") + prompt("Output Specification") + interest(1) + } + field(EGU, DBF_STRING) { + interest(1) + size(16) + prop(YES) + promptgroup("80 - Display") + prompt("Engineering Units") + } + field(HOPR, DBF_DOUBLE) { + prompt("High Operating Range") + promptgroup("80 - Display") + prop(YES) + interest(1) + } + field(LOPR, DBF_DOUBLE) { + interest(1) + promptgroup("80 - Display") + prop(YES) + prompt("Low Operating Range") + } + field(NELM, DBF_ULONG) { + special(SPC_NOMOD) + interest(1) + prompt("Number of Elements") + initial("1") + promptgroup("30 - Action") + } + field(FTVL, DBF_MENU) { + interest(1) + menu(menuFtype) + special(SPC_NOMOD) + promptgroup("30 - Action") + prompt("Field Type of Value") + } + field(NORD, DBF_ULONG) { + special(SPC_NOMOD) + prompt("Number elements read") + } + field(BPTR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Buffer Pointer") + extra("void * bptr") + } + field(SIML, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + interest(1) + } + field(SIMM, DBF_MENU) { + menu(menuYesNo) + special(SPC_MOD) + interest(1) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + promptgroup("90 - Simulate") + prompt("Simulation Mode Severity") + } + field(SIOL, DBF_OUTLINK) { + interest(1) + prompt("Simulation Output Link") + promptgroup("90 - Simulate") + } + field(OLDSIMM, DBF_MENU) { + menu(menuSimm) + special(SPC_NOMOD) + interest(4) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + interest(1) + menu(menuScan) + promptgroup("90 - Simulate") + prompt("Sim. Mode Scan") + initial("65535") + } + field(SDLY, DBF_DOUBLE) { + prompt("Sim. Mode Async Delay") + initial("-1.0") + promptgroup("90 - Simulate") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + special(SPC_NOMOD) + interest(4) + } + field(MPST, DBF_MENU) { + prompt("Post Value Monitors") + promptgroup("80 - Display") + menu(aaoPOST) + interest(1) + } + field(APST, DBF_MENU) { + promptgroup("80 - Display") + prompt("Post Archive Monitors") + interest(1) + menu(aaoPOST) + } + field(HASH, DBF_ULONG) { + interest(3) + prompt("Hash of OnChange data.") + } +} +device(aao, CONSTANT, devAaoSoft, "Soft Channel") +recordtype(mbboDirect) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + promptgroup("10 - Common") + prompt("Descriptor") + size(41) + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + size(29) + special(SPC_AS) + } + field(SCAN, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuScan) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + prompt("Scan Phase") + promptgroup("20 - Scan") + special(SPC_SCAN) + interest(1) + } + field(EVNT, DBF_STRING) { + interest(1) + special(SPC_SCAN) + size(40) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + prompt("Time Stamp Event") + promptgroup("20 - Scan") + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + interest(4) + special(SPC_NOMOD) + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + interest(4) + special(SPC_NOMOD) + } + field(BKLNK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + prompt("Force Processing") + pp(TRUE) + } + field(STAT, DBF_MENU) { + prompt("Alarm Status") + initial("UDF") + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(SEVR, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKS, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + menu(menuYesNo) + special(SPC_NOMOD) + interest(2) + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(2) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + special(SPC_NOMOD) + interest(1) + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + interest(1) + special(SPC_NOMOD) + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + extra("struct processNotify *ppn") + prompt("pprocessNotify") + special(SPC_NOMOD) + interest(4) + } + field(PPNR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + interest(4) + special(SPC_NOMOD) + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of RSET") + extra("struct typed_rset *rset") + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + special(SPC_NOMOD) + interest(4) + } + field(PRIO, DBF_MENU) { + prompt("Scheduling Priority") + promptgroup("20 - Scan") + menu(menuPriority) + special(SPC_SCAN) + interest(1) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + interest(1) + prompt("Undefined") + initial("1") + pp(TRUE) + promptgroup("10 - Common") + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Undefined Alarm Sevrty") + initial("INVALID") + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + interest(2) + special(SPC_NOMOD) + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_LONG) { + asl(ASL0) + promptgroup("50 - Output") + pp(TRUE) + prompt("Word") + } + field(OMSL, DBF_MENU) { + promptgroup("50 - Output") + menu(menuOmsl) + special(SPC_RESET) + pp(TRUE) + prompt("Output Mode Select") + interest(1) + } + field(NOBT, DBF_SHORT) { + promptgroup("50 - Output") + prompt("Number of Bits") + interest(1) + special(SPC_NOMOD) + } + field(DOL, DBF_INLINK) { + promptgroup("40 - Input") + prompt("Desired Output Loc") + interest(1) + } + field(OUT, DBF_OUTLINK) { + interest(1) + prompt("Output Specification") + promptgroup("50 - Output") + } + field(RVAL, DBF_ULONG) { + prompt("Raw Value") + pp(TRUE) + special(SPC_NOMOD) + } + field(ORAW, DBF_ULONG) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Raw Value") + } + field(RBV, DBF_ULONG) { + prompt("Readback Value") + special(SPC_NOMOD) + } + field(ORBV, DBF_ULONG) { + prompt("Prev Readback Value") + special(SPC_NOMOD) + interest(3) + } + field(MASK, DBF_ULONG) { + prompt("Hardware Mask") + interest(1) + special(SPC_NOMOD) + } + field(MLST, DBF_LONG) { + interest(3) + special(SPC_NOMOD) + prompt("Last Value Monitored") + } + field(SHFT, DBF_USHORT) { + interest(1) + promptgroup("50 - Output") + prompt("Shift") + } + field(SIOL, DBF_OUTLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Output Link") + interest(1) + } + field(SIML, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + interest(1) + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + interest(1) + special(SPC_MOD) + menu(menuYesNo) + } + field(SIMS, DBF_MENU) { + menu(menuAlarmSevr) + interest(2) + prompt("Simulation Mode Severity") + promptgroup("90 - Simulate") + } + field(OLDSIMM, DBF_MENU) { + prompt("Prev. Simulation Mode") + special(SPC_NOMOD) + menu(menuSimm) + interest(4) + } + field(SSCN, DBF_MENU) { + menu(menuScan) + interest(1) + initial("65535") + prompt("Sim. Mode Scan") + promptgroup("90 - Simulate") + } + field(SDLY, DBF_DOUBLE) { + interest(2) + prompt("Sim. Mode Async Delay") + initial("-1.0") + promptgroup("90 - Simulate") + } + field(SIMPVT, DBF_NOACCESS) { + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + special(SPC_NOMOD) + interest(4) + } + field(IVOA, DBF_MENU) { + promptgroup("50 - Output") + prompt("INVALID outpt action") + interest(2) + menu(menuIvoa) + } + field(IVOV, DBF_LONG) { + promptgroup("50 - Output") + prompt("INVALID output value") + interest(2) + } + field(B0, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 0") + promptgroup("51 - Output 0-7") + special(SPC_MOD) + interest(1) + } + field(B1, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("51 - Output 0-7") + pp(TRUE) + prompt("Bit 1") + } + field(B2, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("51 - Output 0-7") + prompt("Bit 2") + pp(TRUE) + } + field(B3, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("51 - Output 0-7") + pp(TRUE) + prompt("Bit 3") + } + field(B4, DBF_UCHAR) { + prompt("Bit 4") + pp(TRUE) + promptgroup("51 - Output 0-7") + special(SPC_MOD) + interest(1) + } + field(B5, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("51 - Output 0-7") + pp(TRUE) + prompt("Bit 5") + } + field(B6, DBF_UCHAR) { + promptgroup("51 - Output 0-7") + pp(TRUE) + prompt("Bit 6") + interest(1) + special(SPC_MOD) + } + field(B7, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("51 - Output 0-7") + prompt("Bit 7") + pp(TRUE) + } + field(B8, DBF_UCHAR) { + promptgroup("52 - Output 8-15") + pp(TRUE) + prompt("Bit 8") + interest(1) + special(SPC_MOD) + } + field(B9, DBF_UCHAR) { + promptgroup("52 - Output 8-15") + pp(TRUE) + prompt("Bit 9") + interest(1) + special(SPC_MOD) + } + field(BA, DBF_UCHAR) { + special(SPC_MOD) + interest(1) + pp(TRUE) + prompt("Bit 10") + promptgroup("52 - Output 8-15") + } + field(BB, DBF_UCHAR) { + special(SPC_MOD) + interest(1) + pp(TRUE) + prompt("Bit 11") + promptgroup("52 - Output 8-15") + } + field(BC, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("52 - Output 8-15") + prompt("Bit 12") + pp(TRUE) + } + field(BD, DBF_UCHAR) { + promptgroup("52 - Output 8-15") + pp(TRUE) + prompt("Bit 13") + interest(1) + special(SPC_MOD) + } + field(BE, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("52 - Output 8-15") + pp(TRUE) + prompt("Bit 14") + } + field(BF, DBF_UCHAR) { + special(SPC_MOD) + interest(1) + prompt("Bit 15") + pp(TRUE) + promptgroup("52 - Output 8-15") + } + field(B10, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("53 - Output 16-23") + prompt("Bit 16") + pp(TRUE) + } + field(B11, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 17") + promptgroup("53 - Output 16-23") + special(SPC_MOD) + interest(1) + } + field(B12, DBF_UCHAR) { + promptgroup("53 - Output 16-23") + prompt("Bit 18") + pp(TRUE) + interest(1) + special(SPC_MOD) + } + field(B13, DBF_UCHAR) { + special(SPC_MOD) + interest(1) + pp(TRUE) + prompt("Bit 19") + promptgroup("53 - Output 16-23") + } + field(B14, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 20") + promptgroup("53 - Output 16-23") + special(SPC_MOD) + interest(1) + } + field(B15, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 21") + promptgroup("53 - Output 16-23") + special(SPC_MOD) + interest(1) + } + field(B16, DBF_UCHAR) { + special(SPC_MOD) + interest(1) + pp(TRUE) + prompt("Bit 22") + promptgroup("53 - Output 16-23") + } + field(B17, DBF_UCHAR) { + promptgroup("53 - Output 16-23") + pp(TRUE) + prompt("Bit 23") + interest(1) + special(SPC_MOD) + } + field(B18, DBF_UCHAR) { + special(SPC_MOD) + interest(1) + prompt("Bit 24") + pp(TRUE) + promptgroup("54 - Output 24-31") + } + field(B19, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("54 - Output 24-31") + pp(TRUE) + prompt("Bit 25") + } + field(B1A, DBF_UCHAR) { + special(SPC_MOD) + interest(1) + pp(TRUE) + prompt("Bit 26") + promptgroup("54 - Output 24-31") + } + field(B1B, DBF_UCHAR) { + prompt("Bit 27") + pp(TRUE) + promptgroup("54 - Output 24-31") + special(SPC_MOD) + interest(1) + } + field(B1C, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("54 - Output 24-31") + prompt("Bit 28") + pp(TRUE) + } + field(B1D, DBF_UCHAR) { + prompt("Bit 29") + pp(TRUE) + promptgroup("54 - Output 24-31") + special(SPC_MOD) + interest(1) + } + field(B1E, DBF_UCHAR) { + special(SPC_MOD) + interest(1) + prompt("Bit 30") + pp(TRUE) + promptgroup("54 - Output 24-31") + } + field(B1F, DBF_UCHAR) { + interest(1) + special(SPC_MOD) + promptgroup("54 - Output 24-31") + pp(TRUE) + prompt("Bit 31") + } +} +device(mbboDirect, CONSTANT, devMbboDirectSoft, "Soft Channel") +device(mbboDirect, CONSTANT, devMbboDirectSoftRaw, "Raw Soft Channel") +device(mbboDirect, CONSTANT, devMbboDirectSoftCallback, "Async Soft Channel") +device(mbboDirect, INST_IO, asynMbboDirectUInt32Digital, "asynUInt32Digital") +recordtype(printf) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "devSup.h" + % + %/* Declare Device Support Entry Table */ + %typedef struct printfdset { + % long number; + % DEVSUPFUN report; + % DEVSUPFUN init; + % DEVSUPFUN init_record; + % DEVSUPFUN get_ioint_info; + % DEVSUPFUN write_string; + %} printfdset; + % + %/* Number of INPx fields defined */ + %#define PRINTF_NLINKS 10 + field(NAME, DBF_STRING) { + size(61) + special(SPC_NOMOD) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + size(41) + prompt("Descriptor") + promptgroup("10 - Common") + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + special(SPC_AS) + size(29) + } + field(SCAN, DBF_MENU) { + special(SPC_SCAN) + menu(menuScan) + interest(1) + prompt("Scan Mechanism") + promptgroup("20 - Scan") + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + special(SPC_SCAN) + size(40) + interest(1) + prompt("Event Name") + promptgroup("20 - Scan") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Scanning Disable") + } + field(MLOK, DBF_NOACCESS) { + prompt("Monitor lock") + extra("epicsMutexId mlok") + special(SPC_NOMOD) + interest(4) + } + field(MLIS, DBF_NOACCESS) { + extra("ELLLIST mlis") + prompt("Monitor List") + interest(4) + special(SPC_NOMOD) + } + field(BKLNK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + pp(TRUE) + prompt("Force Processing") + } + field(STAT, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKS, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + menu(menuYesNo) + special(SPC_NOMOD) + interest(2) + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(2) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + interest(1) + special(SPC_NOMOD) + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + special(SPC_NOMOD) + interest(1) + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + interest(1) + special(SPC_NOMOD) + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + interest(4) + special(SPC_NOMOD) + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of RSET") + extra("struct typed_rset *rset") + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + interest(4) + special(SPC_NOMOD) + } + field(DPVT, DBF_NOACCESS) { + extra("void *dpvt") + prompt("Device Private") + interest(4) + special(SPC_NOMOD) + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + prompt("Scheduling Priority") + promptgroup("20 - Scan") + menu(menuPriority) + special(SPC_SCAN) + interest(1) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + prompt("Break Point") + extra("char bkpt") + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + prompt("Undefined") + initial("1") + pp(TRUE) + interest(1) + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + promptgroup("20 - Scan") + prompt("Forward Process Link") + interest(1) + } + field(VAL, DBF_NOACCESS) { + special(SPC_DBADDR) + asl(ASL0) + pp(TRUE) + extra("char *val") + prompt("Result") + } + field(SIZV, DBF_USHORT) { + special(SPC_NOMOD) + interest(1) + prompt("Size of VAL buffer") + initial("41") + promptgroup("30 - Action") + } + field(LEN, DBF_ULONG) { + special(SPC_NOMOD) + prompt("Length of VAL") + } + field(OUT, DBF_OUTLINK) { + prompt("Output Specification") + promptgroup("50 - Output") + interest(1) + } + field(FMT, DBF_STRING) { + prompt("Format String") + pp(TRUE) + promptgroup("30 - Action") + size(81) + } + field(IVLS, DBF_STRING) { + promptgroup("30 - Action") + initial("LNK") + prompt("Invalid Link String") + size(16) + } + field(INP0, DBF_INLINK) { + prompt("Input 0") + promptgroup("40 - Input") + interest(1) + } + field(INP1, DBF_INLINK) { + promptgroup("40 - Input") + prompt("Input 1") + interest(1) + } + field(INP2, DBF_INLINK) { + interest(1) + promptgroup("40 - Input") + prompt("Input 2") + } + field(INP3, DBF_INLINK) { + interest(1) + prompt("Input 3") + promptgroup("40 - Input") + } + field(INP4, DBF_INLINK) { + interest(1) + promptgroup("40 - Input") + prompt("Input 4") + } + field(INP5, DBF_INLINK) { + promptgroup("40 - Input") + prompt("Input 5") + interest(1) + } + field(INP6, DBF_INLINK) { + interest(1) + promptgroup("40 - Input") + prompt("Input 6") + } + field(INP7, DBF_INLINK) { + interest(1) + promptgroup("40 - Input") + prompt("Input 7") + } + field(INP8, DBF_INLINK) { + interest(1) + prompt("Input 8") + promptgroup("40 - Input") + } + field(INP9, DBF_INLINK) { + interest(1) + prompt("Input 9") + promptgroup("40 - Input") + } +} +device(printf, CONSTANT, devPrintfSoft, "Soft Channel") +device(printf, CONSTANT, devPrintfSoftCallback, "Async Soft Channel") +device(printf, INST_IO, devPrintfStdio, "stdio") +recordtype(permissive) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + promptgroup("10 - Common") + prompt("Access Security Group") + } + field(SCAN, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuScan) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + prompt("Time Stamp Event") + promptgroup("20 - Scan") + } + field(TSEL, DBF_INLINK) { + interest(1) + prompt("Time Stamp Link") + promptgroup("20 - Scan") + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + interest(4) + special(SPC_NOMOD) + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + prompt("Force Processing") + pp(TRUE) + } + field(STAT, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(ACKS, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + special(SPC_NOMOD) + interest(1) + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + interest(1) + special(SPC_NOMOD) + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + interest(1) + special(SPC_NOMOD) + } + field(ASP, DBF_NOACCESS) { + prompt("Access Security Pvt") + extra("struct asgMember *asp") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + extra("struct processNotify *ppn") + prompt("pprocessNotify") + special(SPC_NOMOD) + interest(4) + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + interest(4) + special(SPC_NOMOD) + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct scan_element *spvt") + prompt("Scan Private") + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct dset *dset") + prompt("DSET address") + } + field(DPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + } + field(LSET, DBF_NOACCESS) { + extra("struct lockRecord *lset") + prompt("Lock Set") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + special(SPC_SCAN) + menu(menuPriority) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + extra("char bkpt") + prompt("Break Point") + special(SPC_NOMOD) + interest(1) + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + pp(TRUE) + initial("1") + prompt("Undefined") + interest(1) + } + field(UDFS, DBF_MENU) { + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(TIME, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VAL, DBF_USHORT) { + asl(ASL0) + promptgroup("40 - Input") + pp(TRUE) + prompt("Status") + } + field(WFLG, DBF_USHORT) { + prompt("Wait Flag") + pp(TRUE) + } + field(LABL, DBF_STRING) { + size(20) + interest(1) + pp(TRUE) + prompt("Button Label") + promptgroup("80 - Display") + } + field(OVAL, DBF_USHORT) { + prompt("Old Status") + interest(3) + special(SPC_NOMOD) + } + field(OFLG, DBF_USHORT) { + prompt("Old Flag") + special(SPC_NOMOD) + interest(3) + } +} +recordtype(waveform) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + prompt("Descriptor") + promptgroup("10 - Common") + size(41) + } + field(ASG, DBF_STRING) { + size(29) + special(SPC_AS) + promptgroup("10 - Common") + prompt("Access Security Group") + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuScan) + interest(1) + } + field(PINI, DBF_MENU) { + menu(menuPini) + interest(1) + prompt("Process at iocInit") + promptgroup("20 - Scan") + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + pp(TRUE) + prompt("Force Processing") + } + field(STAT, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + } + field(ACKS, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + interest(2) + special(SPC_NOMOD) + menu(menuYesNo) + } + field(DISS, DBF_MENU) { + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + special(SPC_NOMOD) + interest(1) + } + field(PUTF, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + special(SPC_NOMOD) + interest(1) + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + special(SPC_NOMOD) + interest(4) + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of RSET") + extra("struct typed_rset *rset") + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + extra("void *dpvt") + prompt("Device Private") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + prompt("Scheduling Priority") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuPriority) + interest(1) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + extra("char bkpt") + prompt("Break Point") + special(SPC_NOMOD) + interest(1) + } + field(UDF, DBF_UCHAR) { + interest(1) + promptgroup("10 - Common") + initial("1") + pp(TRUE) + prompt("Undefined") + } + field(UDFS, DBF_MENU) { + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + interest(2) + special(SPC_NOMOD) + } + field(FLNK, DBF_FWDLINK) { + promptgroup("20 - Scan") + prompt("Forward Process Link") + interest(1) + } + field(VAL, DBF_NOACCESS) { + prompt("Value") + pp(TRUE) + extra("void * val") + special(SPC_DBADDR) + asl(ASL0) + } + field(RARM, DBF_SHORT) { + prompt("Rearm the waveform") + pp(TRUE) + promptgroup("30 - Action") + interest(1) + } + field(PREC, DBF_SHORT) { + interest(1) + prompt("Display Precision") + prop(YES) + promptgroup("80 - Display") + } + field(INP, DBF_INLINK) { + promptgroup("40 - Input") + prompt("Input Specification") + interest(1) + } + field(EGU, DBF_STRING) { + prompt("Engineering Units") + promptgroup("80 - Display") + prop(YES) + size(16) + interest(1) + } + field(HOPR, DBF_DOUBLE) { + prompt("High Operating Range") + promptgroup("80 - Display") + prop(YES) + interest(1) + } + field(LOPR, DBF_DOUBLE) { + prop(YES) + promptgroup("80 - Display") + prompt("Low Operating Range") + interest(1) + } + field(NELM, DBF_ULONG) { + initial("1") + prompt("Number of Elements") + promptgroup("30 - Action") + special(SPC_NOMOD) + interest(1) + } + field(FTVL, DBF_MENU) { + menu(menuFtype) + special(SPC_NOMOD) + interest(1) + prompt("Field Type of Value") + promptgroup("30 - Action") + } + field(BUSY, DBF_SHORT) { + prompt("Busy Indicator") + special(SPC_NOMOD) + } + field(NORD, DBF_ULONG) { + prompt("Number elements read") + special(SPC_NOMOD) + } + field(BPTR, DBF_NOACCESS) { + prompt("Buffer Pointer") + extra("void * bptr") + special(SPC_NOMOD) + interest(4) + } + field(SIOL, DBF_INLINK) { + interest(1) + promptgroup("90 - Simulate") + prompt("Simulation Input Link") + } + field(SIML, DBF_INLINK) { + interest(1) + prompt("Simulation Mode Link") + promptgroup("90 - Simulate") + } + field(SIMM, DBF_MENU) { + interest(1) + special(SPC_MOD) + menu(menuYesNo) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + prompt("Simulation Mode Severity") + promptgroup("90 - Simulate") + menu(menuAlarmSevr) + interest(2) + } + field(OLDSIMM, DBF_MENU) { + prompt("Prev. Simulation Mode") + special(SPC_NOMOD) + menu(menuSimm) + interest(4) + } + field(SSCN, DBF_MENU) { + prompt("Sim. Mode Scan") + initial("65535") + promptgroup("90 - Simulate") + menu(menuScan) + interest(1) + } + field(SDLY, DBF_DOUBLE) { + promptgroup("90 - Simulate") + prompt("Sim. Mode Async Delay") + initial("-1.0") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + prompt("Sim. Mode Private") + extra("epicsCallback *simpvt") + special(SPC_NOMOD) + interest(4) + } + field(MPST, DBF_MENU) { + interest(1) + menu(waveformPOST) + promptgroup("80 - Display") + prompt("Post Value Monitors") + } + field(APST, DBF_MENU) { + menu(waveformPOST) + interest(1) + prompt("Post Archive Monitors") + promptgroup("80 - Display") + } + field(HASH, DBF_ULONG) { + interest(3) + prompt("Hash of OnChange data.") + } +} +device(waveform, CONSTANT, devWfSoft, "Soft Channel") +device(waveform, INST_IO, asynWfOctetCmdResponse, "asynOctetCmdResponse") +device(waveform, INST_IO, asynWfOctetWriteRead, "asynOctetWriteRead") +device(waveform, INST_IO, asynWfOctetRead, "asynOctetRead") +device(waveform, INST_IO, asynWfOctetWrite, "asynOctetWrite") +device(waveform, INST_IO, asynWfOctetWriteBinary, "asynOctetWriteBinary") +device(waveform, INST_IO, asynInt8ArrayWfIn, "asynInt8ArrayIn") +device(waveform, INST_IO, asynInt8ArrayWfOut, "asynInt8ArrayOut") +device(waveform, INST_IO, asynInt16ArrayWfIn, "asynInt16ArrayIn") +device(waveform, INST_IO, asynInt16ArrayWfOut, "asynInt16ArrayOut") +device(waveform, INST_IO, asynInt32ArrayWfIn, "asynInt32ArrayIn") +device(waveform, INST_IO, asynInt32ArrayWfOut, "asynInt32ArrayOut") +device(waveform, INST_IO, asynInt32TimeSeries, "asynInt32TimeSeries") +device(waveform, INST_IO, asynFloat32ArrayWfIn, "asynFloat32ArrayIn") +device(waveform, INST_IO, asynFloat32ArrayWfOut, "asynFloat32ArrayOut") +device(waveform, INST_IO, asynFloat64ArrayWfIn, "asynFloat64ArrayIn") +device(waveform, INST_IO, asynFloat64ArrayWfOut, "asynFloat64ArrayOut") +device(waveform, INST_IO, asynFloat64TimeSeries, "asynFloat64TimeSeries") +device(waveform, INST_IO, asynInt64ArrayWfIn, "asynInt64ArrayIn") +device(waveform, INST_IO, asynInt64ArrayWfOut, "asynInt64ArrayOut") +device(waveform, INST_IO, asynInt64TimeSeries, "asynInt64TimeSeries") +recordtype(asyn) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + promptgroup("10 - Common") + prompt("Descriptor") + size(41) + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuScan) + interest(1) + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + prompt("Time Stamp Event") + promptgroup("20 - Scan") + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + prompt("Monitor lock") + extra("epicsMutexId mlok") + special(SPC_NOMOD) + interest(4) + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor List") + extra("ELLLIST mlis") + } + field(BKLNK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + prompt("Force Processing") + pp(TRUE) + } + field(STAT, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + prompt("Alarm Status") + initial("UDF") + } + field(SEVR, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + menu(menuAlarmStat) + special(SPC_NOMOD) + interest(2) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKT, DBF_MENU) { + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + promptgroup("70 - Alarm") + initial("YES") + prompt("Alarm Ack Transient") + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + interest(2) + special(SPC_NOMOD) + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + special(SPC_NOMOD) + interest(1) + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + special(SPC_NOMOD) + interest(1) + } + field(ASP, DBF_NOACCESS) { + extra("struct asgMember *asp") + prompt("Access Security Pvt") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + special(SPC_NOMOD) + interest(4) + } + field(SPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of RSET") + extra("struct typed_rset *rset") + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("void *dpvt") + prompt("Device Private") + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Lock Set") + extra("struct lockRecord *lset") + } + field(PRIO, DBF_MENU) { + prompt("Scheduling Priority") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuPriority) + interest(1) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + prompt("Break Point") + extra("char bkpt") + interest(1) + special(SPC_NOMOD) + } + field(UDF, DBF_UCHAR) { + interest(1) + initial("1") + pp(TRUE) + prompt("Undefined") + promptgroup("10 - Common") + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VAL, DBF_LONG) { + asl(ASL0) + interest(4) + prompt("Value field (unused)") + } + field(PORT, DBF_STRING) { + initial("") + prompt("asyn port") + interest(1) + promptgroup("40 - Input") + size(40) + special(SPC_MOD) + } + field(ADDR, DBF_LONG) { + interest(1) + special(SPC_MOD) + promptgroup("40 - Input") + prompt("asyn address") + initial("0") + } + field(PCNCT, DBF_MENU) { + menu(asynCONNECT) + special(SPC_MOD) + interest(2) + prompt("Port Connect/Disconnect") + } + field(DRVINFO, DBF_STRING) { + size(40) + special(SPC_MOD) + promptgroup("40 - Input") + interest(2) + initial("") + prompt("Driver info string") + } + field(REASON, DBF_LONG) { + prompt("asynUser->reason") + special(SPC_MOD) + interest(2) + } + field(TMOD, DBF_MENU) { + menu(asynTMOD) + interest(1) + prompt("Transaction mode") + promptgroup("40 - Input") + } + field(TMOT, DBF_DOUBLE) { + promptgroup("40 - Input") + prompt("Timeout (sec)") + initial("1.0") + interest(1) + } + field(IFACE, DBF_MENU) { + special(SPC_MOD) + menu(asynINTERFACE) + interest(2) + prompt("Interface") + promptgroup("40 - Input") + } + field(OCTETIV, DBF_LONG) { + interest(2) + prompt("asynOctet is valid") + } + field(OPTIONIV, DBF_LONG) { + prompt("asynOption is valid") + interest(2) + } + field(GPIBIV, DBF_LONG) { + interest(2) + prompt("asynGPIB is valid") + } + field(I32IV, DBF_LONG) { + interest(2) + prompt("asynInt32 is valid") + } + field(UI32IV, DBF_LONG) { + interest(2) + prompt("asynUInt32Digital is valid") + } + field(F64IV, DBF_LONG) { + interest(2) + prompt("asynFloat64 is valid") + } + field(AOUT, DBF_STRING) { + prompt("Output (command) string") + pp(TRUE) + promptgroup("50 - Output") + size(40) + interest(1) + } + field(OEOS, DBF_STRING) { + promptgroup("50 - Output") + prompt("Output delimiter") + interest(1) + size(40) + special(SPC_MOD) + } + field(BOUT, DBF_CHAR) { + special(SPC_DBADDR) + interest(1) + prompt("Output binary data") + pp(TRUE) + } + field(OPTR, DBF_NOACCESS) { + prompt("Output buffer pointer") + extra("void *optr") + special(SPC_NOMOD) + interest(4) + } + field(OMAX, DBF_LONG) { + special(SPC_NOMOD) + interest(1) + prompt("Max. size of output array") + initial("80") + promptgroup("50 - Output") + } + field(NOWT, DBF_LONG) { + initial("80") + prompt("Number of bytes to write") + promptgroup("50 - Output") + interest(1) + } + field(NAWT, DBF_LONG) { + prompt("Number of bytes actually written") + interest(1) + } + field(OFMT, DBF_MENU) { + interest(1) + menu(asynFMT) + promptgroup("50 - Output") + prompt("Output format") + } + field(AINP, DBF_STRING) { + prompt("Input (response) string") + special(SPC_NOMOD) + size(40) + interest(1) + } + field(TINP, DBF_STRING) { + special(SPC_NOMOD) + size(40) + asl(ASL0) + interest(1) + prompt("Translated input string") + } + field(IEOS, DBF_STRING) { + size(40) + special(SPC_MOD) + interest(1) + prompt("Input Delimiter") + promptgroup("40 - Input") + } + field(BINP, DBF_CHAR) { + prompt("Input binary data") + special(SPC_DBADDR) + asl(ASL0) + } + field(IPTR, DBF_NOACCESS) { + extra("void *iptr") + prompt("Input buffer pointer") + special(SPC_NOMOD) + size(4) + interest(4) + } + field(IMAX, DBF_LONG) { + special(SPC_NOMOD) + interest(1) + prompt("Max. size of input array") + initial("80") + promptgroup("40 - Input") + } + field(NRRD, DBF_LONG) { + promptgroup("40 - Input") + prompt("Number of bytes to read") + interest(1) + } + field(NORD, DBF_LONG) { + prompt("Number of bytes read") + interest(1) + special(SPC_NOMOD) + } + field(IFMT, DBF_MENU) { + promptgroup("40 - Input") + prompt("Input format") + interest(1) + menu(asynFMT) + } + field(EOMR, DBF_MENU) { + interest(1) + special(SPC_NOMOD) + menu(asynEOMREASON) + prompt("EOM reason") + } + field(I32INP, DBF_LONG) { + prompt("asynInt32 input") + special(SPC_NOMOD) + interest(2) + } + field(I32OUT, DBF_LONG) { + promptgroup("50 - Output") + pp(TRUE) + prompt("asynInt32 output") + interest(2) + } + field(UI32INP, DBF_ULONG) { + prompt("asynUInt32Digital input") + interest(2) + special(SPC_NOMOD) + } + field(UI32OUT, DBF_ULONG) { + interest(2) + promptgroup("50 - Output") + prompt("asynUInt32Digital output") + pp(TRUE) + } + field(UI32MASK, DBF_ULONG) { + interest(2) + special(SPC_MOD) + promptgroup("50 - Output") + initial("0xffffffff") + prompt("asynUInt32Digital mask") + } + field(F64INP, DBF_DOUBLE) { + prompt("asynFloat64 input") + special(SPC_NOMOD) + interest(2) + } + field(F64OUT, DBF_DOUBLE) { + interest(2) + promptgroup("50 - Output") + pp(TRUE) + prompt("asynFloat64 output") + } + field(BAUD, DBF_MENU) { + promptgroup("40 - Input") + prompt("Baud rate") + interest(2) + menu(serialBAUD) + special(SPC_MOD) + } + field(LBAUD, DBF_LONG) { + interest(2) + special(SPC_MOD) + promptgroup("40 - Input") + prompt("Baud rate") + } + field(PRTY, DBF_MENU) { + promptgroup("40 - Input") + prompt("Parity") + interest(2) + menu(serialPRTY) + special(SPC_MOD) + } + field(DBIT, DBF_MENU) { + interest(2) + menu(serialDBIT) + special(SPC_MOD) + promptgroup("40 - Input") + prompt("Data bits") + } + field(SBIT, DBF_MENU) { + interest(2) + special(SPC_MOD) + menu(serialSBIT) + promptgroup("40 - Input") + prompt("Stop bits") + } + field(MCTL, DBF_MENU) { + promptgroup("40 - Input") + prompt("Modem control") + interest(2) + menu(serialMCTL) + special(SPC_MOD) + } + field(FCTL, DBF_MENU) { + prompt("Flow control") + promptgroup("40 - Input") + special(SPC_MOD) + menu(serialFCTL) + interest(2) + } + field(IXON, DBF_MENU) { + promptgroup("40 - Input") + prompt("Output XON/XOFF") + interest(2) + menu(serialIX) + special(SPC_MOD) + } + field(IXOFF, DBF_MENU) { + promptgroup("40 - Input") + prompt("Input XON/XOFF") + interest(2) + special(SPC_MOD) + menu(serialIX) + } + field(IXANY, DBF_MENU) { + prompt("XON=any character") + promptgroup("40 - Input") + menu(serialIX) + special(SPC_MOD) + interest(2) + } + field(HOSTINFO, DBF_STRING) { + interest(1) + initial("") + prompt("host info") + special(SPC_MOD) + size(40) + promptgroup("40 - Input") + } + field(DRTO, DBF_MENU) { + prompt("Disconnect on timeout") + promptgroup("40 - Input") + menu(ipDRTO) + special(SPC_MOD) + interest(2) + } + field(UCMD, DBF_MENU) { + menu(gpibUCMD) + interest(2) + prompt("Universal command") + pp(TRUE) + promptgroup("50 - Output") + } + field(ACMD, DBF_MENU) { + promptgroup("50 - Output") + prompt("Addressed command") + pp(TRUE) + interest(2) + menu(gpibACMD) + } + field(SPR, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Serial poll response") + } + field(TMSK, DBF_LONG) { + special(SPC_MOD) + interest(1) + prompt("Trace mask") + promptgroup("80 - Display") + } + field(TB0, DBF_MENU) { + interest(1) + menu(asynTRACE) + special(SPC_MOD) + promptgroup("80 - Display") + prompt("Trace error") + } + field(TB1, DBF_MENU) { + prompt("Trace IO device") + promptgroup("80 - Display") + menu(asynTRACE) + special(SPC_MOD) + interest(1) + } + field(TB2, DBF_MENU) { + menu(asynTRACE) + special(SPC_MOD) + interest(1) + prompt("Trace IO filter") + promptgroup("80 - Display") + } + field(TB3, DBF_MENU) { + prompt("Trace IO driver") + promptgroup("80 - Display") + special(SPC_MOD) + menu(asynTRACE) + interest(1) + } + field(TB4, DBF_MENU) { + promptgroup("80 - Display") + prompt("Trace flow") + interest(1) + menu(asynTRACE) + special(SPC_MOD) + } + field(TB5, DBF_MENU) { + menu(asynTRACE) + special(SPC_MOD) + interest(1) + prompt("Trace warning") + promptgroup("80 - Display") + } + field(TIOM, DBF_LONG) { + special(SPC_MOD) + interest(1) + prompt("Trace I/O mask") + promptgroup("80 - Display") + } + field(TIB0, DBF_MENU) { + promptgroup("80 - Display") + prompt("Trace IO ASCII") + interest(1) + menu(asynTRACE) + special(SPC_MOD) + } + field(TIB1, DBF_MENU) { + interest(1) + special(SPC_MOD) + menu(asynTRACE) + promptgroup("80 - Display") + prompt("Trace IO escape") + } + field(TIB2, DBF_MENU) { + special(SPC_MOD) + menu(asynTRACE) + interest(1) + prompt("Trace IO hex") + promptgroup("80 - Display") + } + field(TINM, DBF_LONG) { + promptgroup("80 - Display") + prompt("Trace Info mask") + interest(1) + special(SPC_MOD) + } + field(TINB0, DBF_MENU) { + prompt("Trace Info Time") + promptgroup("80 - Display") + menu(asynTRACE) + special(SPC_MOD) + interest(1) + } + field(TINB1, DBF_MENU) { + prompt("Trace Info Port") + promptgroup("80 - Display") + special(SPC_MOD) + menu(asynTRACE) + interest(1) + } + field(TINB2, DBF_MENU) { + prompt("Trace Info Source") + promptgroup("80 - Display") + menu(asynTRACE) + special(SPC_MOD) + interest(1) + } + field(TINB3, DBF_MENU) { + promptgroup("80 - Display") + prompt("Trace Info Thread") + interest(1) + special(SPC_MOD) + menu(asynTRACE) + } + field(TSIZ, DBF_LONG) { + special(SPC_MOD) + interest(1) + prompt("Trace IO truncate size") + promptgroup("80 - Display") + } + field(TFIL, DBF_STRING) { + interest(1) + size(40) + special(SPC_MOD) + promptgroup("80 - Display") + prompt("Trace IO file") + } + field(AUCT, DBF_MENU) { + interest(1) + menu(asynAUTOCONNECT) + special(SPC_MOD) + promptgroup("40 - Input") + prompt("Autoconnect") + } + field(CNCT, DBF_MENU) { + interest(1) + special(SPC_MOD) + menu(asynCONNECT) + promptgroup("40 - Input") + prompt("Connect/Disconnect") + } + field(ENBL, DBF_MENU) { + interest(1) + menu(asynENABLE) + special(SPC_MOD) + promptgroup("40 - Input") + prompt("Enable/Disable") + } + field(ERRS, DBF_NOACCESS) { + prompt("Error string") + extra("char *errs") + special(SPC_DBADDR) + interest(4) + } + field(AQR, DBF_UCHAR) { + interest(4) + special(SPC_MOD) + prompt("Abort queueRequest") + } +} +device(asyn, INST_IO, asynRecordDevice, "asynRecordDevice") +recordtype(dfanout) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + size(41) + prompt("Descriptor") + promptgroup("10 - Common") + } + field(ASG, DBF_STRING) { + prompt("Access Security Group") + promptgroup("10 - Common") + special(SPC_AS) + size(29) + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuScan) + interest(1) + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + special(SPC_SCAN) + interest(1) + prompt("Scan Phase") + promptgroup("20 - Scan") + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + special(SPC_NOMOD) + interest(4) + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + initial("UDF") + prompt("Alarm Status") + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + menu(menuAlarmStat) + special(SPC_NOMOD) + interest(2) + } + field(NSEV, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + } + field(ACKT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuYesNo) + interest(2) + prompt("Alarm Ack Transient") + initial("YES") + promptgroup("70 - Alarm") + } + field(DISS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + special(SPC_NOMOD) + interest(1) + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + special(SPC_NOMOD) + interest(4) + } + field(DSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + } + field(LSET, DBF_NOACCESS) { + extra("struct lockRecord *lset") + prompt("Lock Set") + special(SPC_NOMOD) + interest(4) + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + special(SPC_SCAN) + menu(menuPriority) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + pp(TRUE) + initial("1") + prompt("Undefined") + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Undefined Alarm Sevrty") + initial("INVALID") + } + field(TIME, DBF_NOACCESS) { + extra("epicsTimeStamp time") + prompt("Time") + interest(2) + special(SPC_NOMOD) + } + field(FLNK, DBF_FWDLINK) { + promptgroup("20 - Scan") + prompt("Forward Process Link") + interest(1) + } + field(VAL, DBF_DOUBLE) { + pp(TRUE) + prompt("Desired Output") + promptgroup("40 - Input") + asl(ASL0) + } + field(SELM, DBF_MENU) { + promptgroup("30 - Action") + prompt("Select Mechanism") + interest(1) + menu(dfanoutSELM) + } + field(SELN, DBF_USHORT) { + prompt("Link Selection") + initial("1") + interest(1) + } + field(SELL, DBF_INLINK) { + interest(1) + prompt("Link Selection Loc") + promptgroup("30 - Action") + } + field(OUTA, DBF_OUTLINK) { + promptgroup("50 - Output") + prompt("Output Spec A") + interest(1) + } + field(OUTB, DBF_OUTLINK) { + interest(1) + prompt("Output Spec B") + promptgroup("50 - Output") + } + field(OUTC, DBF_OUTLINK) { + prompt("Output Spec C") + promptgroup("50 - Output") + interest(1) + } + field(OUTD, DBF_OUTLINK) { + interest(1) + prompt("Output Spec D") + promptgroup("50 - Output") + } + field(OUTE, DBF_OUTLINK) { + interest(1) + promptgroup("50 - Output") + prompt("Output Spec E") + } + field(OUTF, DBF_OUTLINK) { + prompt("Output Spec F") + promptgroup("50 - Output") + interest(1) + } + field(OUTG, DBF_OUTLINK) { + prompt("Output Spec G") + promptgroup("50 - Output") + interest(1) + } + field(OUTH, DBF_OUTLINK) { + prompt("Output Spec H") + promptgroup("50 - Output") + interest(1) + } + field(DOL, DBF_INLINK) { + prompt("Desired Output Loc") + promptgroup("40 - Input") + interest(1) + } + field(OMSL, DBF_MENU) { + interest(1) + menu(menuOmsl) + promptgroup("50 - Output") + prompt("Output Mode Select") + } + field(EGU, DBF_STRING) { + size(16) + interest(1) + prompt("Engineering Units") + promptgroup("80 - Display") + prop(YES) + } + field(PREC, DBF_SHORT) { + interest(1) + promptgroup("80 - Display") + prop(YES) + prompt("Display Precision") + } + field(HOPR, DBF_DOUBLE) { + promptgroup("80 - Display") + prop(YES) + prompt("High Operating Range") + interest(1) + } + field(LOPR, DBF_DOUBLE) { + interest(1) + prompt("Low Operating Range") + promptgroup("80 - Display") + prop(YES) + } + field(HIHI, DBF_DOUBLE) { + prompt("Hihi Alarm Limit") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + interest(1) + } + field(LOLO, DBF_DOUBLE) { + interest(1) + pp(TRUE) + prompt("Lolo Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + } + field(HIGH, DBF_DOUBLE) { + interest(1) + pp(TRUE) + prompt("High Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + } + field(LOW, DBF_DOUBLE) { + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Low Alarm Limit") + interest(1) + } + field(HHSV, DBF_MENU) { + prompt("Hihi Severity") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LLSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("Lolo Severity") + promptgroup("70 - Alarm") + prop(YES) + } + field(HSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("High Severity") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + } + field(LSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("Low Severity") + promptgroup("70 - Alarm") + prop(YES) + } + field(HYST, DBF_DOUBLE) { + prompt("Alarm Deadband") + promptgroup("70 - Alarm") + interest(1) + } + field(ADEL, DBF_DOUBLE) { + interest(1) + prompt("Archive Deadband") + promptgroup("80 - Display") + } + field(MDEL, DBF_DOUBLE) { + interest(1) + prompt("Monitor Deadband") + promptgroup("80 - Display") + } + field(LALM, DBF_DOUBLE) { + prompt("Last Value Alarmed") + interest(3) + special(SPC_NOMOD) + } + field(ALST, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Last Value Archived") + } + field(MLST, DBF_DOUBLE) { + prompt("Last Val Monitored") + special(SPC_NOMOD) + interest(3) + } +} +recordtype(subArray) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + special(SPC_NOMOD) + size(61) + } + field(DESC, DBF_STRING) { + size(41) + prompt("Descriptor") + promptgroup("10 - Common") + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + size(29) + special(SPC_AS) + } + field(SCAN, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuScan) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + special(SPC_SCAN) + interest(1) + prompt("Scan Phase") + promptgroup("20 - Scan") + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + initial("1") + prompt("Disable Value") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(ACKT, DBF_MENU) { + menu(menuYesNo) + special(SPC_NOMOD) + interest(2) + prompt("Alarm Ack Transient") + initial("YES") + promptgroup("70 - Alarm") + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + } + field(SPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct scan_element *spvt") + prompt("Scan Private") + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct typed_rset *rset") + prompt("Address of RSET") + } + field(DSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + interest(4) + special(SPC_NOMOD) + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + special(SPC_NOMOD) + interest(4) + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + menu(menuPriority) + special(SPC_SCAN) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + prompt("Undefined") + pp(TRUE) + initial("1") + interest(1) + } + field(UDFS, DBF_MENU) { + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(TIME, DBF_NOACCESS) { + extra("epicsTimeStamp time") + prompt("Time") + interest(2) + special(SPC_NOMOD) + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VAL, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + prompt("Value") + extra("void * val") + pp(TRUE) + } + field(PREC, DBF_SHORT) { + interest(1) + prompt("Display Precision") + promptgroup("80 - Display") + prop(YES) + } + field(FTVL, DBF_MENU) { + prompt("Field Type of Value") + promptgroup("30 - Action") + special(SPC_NOMOD) + menu(menuFtype) + interest(1) + } + field(INP, DBF_INLINK) { + promptgroup("40 - Input") + prompt("Input Specification") + interest(1) + } + field(EGU, DBF_STRING) { + prompt("Engineering Units") + promptgroup("80 - Display") + prop(YES) + size(16) + interest(1) + } + field(HOPR, DBF_DOUBLE) { + interest(1) + prop(YES) + promptgroup("80 - Display") + prompt("High Operating Range") + } + field(LOPR, DBF_DOUBLE) { + prompt("Low Operating Range") + prop(YES) + promptgroup("80 - Display") + interest(1) + } + field(MALM, DBF_ULONG) { + interest(1) + special(SPC_NOMOD) + promptgroup("30 - Action") + prompt("Maximum Elements") + initial("1") + } + field(NELM, DBF_ULONG) { + promptgroup("30 - Action") + prompt("Number of Elements") + pp(TRUE) + initial("1") + } + field(INDX, DBF_ULONG) { + pp(TRUE) + prompt("Substring Index") + promptgroup("30 - Action") + } + field(BUSY, DBF_SHORT) { + special(SPC_NOMOD) + prompt("Busy Indicator") + } + field(NORD, DBF_LONG) { + special(SPC_NOMOD) + prompt("Number elements read") + } + field(BPTR, DBF_NOACCESS) { + extra("void * bptr") + prompt("Buffer Pointer") + interest(4) + special(SPC_NOMOD) + } +} +device(subArray, CONSTANT, devSASoft, "Soft Channel") +recordtype(aai) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + size(61) + special(SPC_NOMOD) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + prompt("Descriptor") + promptgroup("10 - Common") + size(41) + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + size(29) + special(SPC_AS) + } + field(SCAN, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scan Mechanism") + interest(1) + special(SPC_SCAN) + menu(menuScan) + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + interest(1) + special(SPC_SCAN) + size(40) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Monitor lock") + extra("epicsMutexId mlok") + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor List") + extra("ELLLIST mlis") + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + pp(TRUE) + prompt("Force Processing") + } + field(STAT, DBF_MENU) { + prompt("Alarm Status") + initial("UDF") + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + } + field(NSEV, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + prompt("Alarm Ack Transient") + initial("YES") + promptgroup("70 - Alarm") + menu(menuYesNo) + special(SPC_NOMOD) + interest(2) + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(2) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + interest(1) + special(SPC_NOMOD) + } + field(RPRO, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + extra("struct asgMember *asp") + prompt("Access Security Pvt") + special(SPC_NOMOD) + interest(4) + } + field(PPN, DBF_NOACCESS) { + extra("struct processNotify *ppn") + prompt("pprocessNotify") + special(SPC_NOMOD) + interest(4) + } + field(PPNR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct scan_element *spvt") + prompt("Scan Private") + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + interest(4) + special(SPC_NOMOD) + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("void *dpvt") + prompt("Device Private") + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + special(SPC_NOMOD) + interest(4) + } + field(LSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Lock Set") + extra("struct lockRecord *lset") + } + field(PRIO, DBF_MENU) { + prompt("Scheduling Priority") + promptgroup("20 - Scan") + menu(menuPriority) + special(SPC_SCAN) + interest(1) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + interest(1) + prompt("Undefined") + initial("1") + pp(TRUE) + promptgroup("10 - Common") + } + field(UDFS, DBF_MENU) { + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + special(SPC_NOMOD) + interest(2) + } + field(FLNK, DBF_FWDLINK) { + promptgroup("20 - Scan") + prompt("Forward Process Link") + interest(1) + } + field(VAL, DBF_NOACCESS) { + pp(TRUE) + extra("void * val") + prompt("Value") + asl(ASL0) + special(SPC_DBADDR) + } + field(PREC, DBF_SHORT) { + promptgroup("80 - Display") + prop(YES) + prompt("Display Precision") + interest(1) + } + field(INP, DBF_INLINK) { + prompt("Input Specification") + promptgroup("40 - Input") + interest(1) + } + field(EGU, DBF_STRING) { + size(16) + interest(1) + prompt("Engineering Units") + promptgroup("80 - Display") + prop(YES) + } + field(HOPR, DBF_DOUBLE) { + interest(1) + promptgroup("80 - Display") + prop(YES) + prompt("High Operating Range") + } + field(LOPR, DBF_DOUBLE) { + interest(1) + prompt("Low Operating Range") + promptgroup("80 - Display") + prop(YES) + } + field(NELM, DBF_ULONG) { + promptgroup("30 - Action") + initial("1") + prompt("Number of Elements") + interest(1) + special(SPC_NOMOD) + } + field(FTVL, DBF_MENU) { + promptgroup("30 - Action") + prompt("Field Type of Value") + interest(1) + menu(menuFtype) + special(SPC_NOMOD) + } + field(NORD, DBF_ULONG) { + special(SPC_NOMOD) + prompt("Number elements read") + } + field(BPTR, DBF_NOACCESS) { + prompt("Buffer Pointer") + extra("void * bptr") + special(SPC_NOMOD) + interest(4) + } + field(SIML, DBF_INLINK) { + interest(1) + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + interest(1) + menu(menuYesNo) + special(SPC_MOD) + } + field(SIMS, DBF_MENU) { + prompt("Simulation Mode Severity") + promptgroup("90 - Simulate") + menu(menuAlarmSevr) + interest(2) + } + field(SIOL, DBF_INLINK) { + prompt("Simulation Input Link") + promptgroup("90 - Simulate") + interest(1) + } + field(OLDSIMM, DBF_MENU) { + prompt("Prev. Simulation Mode") + special(SPC_NOMOD) + menu(menuSimm) + interest(4) + } + field(SSCN, DBF_MENU) { + prompt("Sim. Mode Scan") + initial("65535") + promptgroup("90 - Simulate") + menu(menuScan) + interest(1) + } + field(SDLY, DBF_DOUBLE) { + initial("-1.0") + prompt("Sim. Mode Async Delay") + promptgroup("90 - Simulate") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + interest(4) + special(SPC_NOMOD) + } + field(MPST, DBF_MENU) { + prompt("Post Value Monitors") + promptgroup("80 - Display") + menu(aaiPOST) + interest(1) + } + field(APST, DBF_MENU) { + interest(1) + menu(aaiPOST) + promptgroup("80 - Display") + prompt("Post Archive Monitors") + } + field(HASH, DBF_ULONG) { + prompt("Hash of OnChange data.") + interest(3) + } +} +device(aai, CONSTANT, devAaiSoft, "Soft Channel") +recordtype(longout) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + promptgroup("10 - Common") + prompt("Descriptor") + size(41) + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + promptgroup("10 - Common") + prompt("Access Security Group") + } + field(SCAN, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scan Mechanism") + interest(1) + menu(menuScan) + special(SPC_SCAN) + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + prompt("Scan Phase") + promptgroup("20 - Scan") + special(SPC_SCAN) + interest(1) + } + field(EVNT, DBF_STRING) { + prompt("Event Name") + promptgroup("20 - Scan") + size(40) + special(SPC_SCAN) + interest(1) + } + field(TSE, DBF_SHORT) { + prompt("Time Stamp Event") + promptgroup("20 - Scan") + interest(1) + } + field(TSEL, DBF_INLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Link") + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor lock") + extra("epicsMutexId mlok") + } + field(MLIS, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + pp(TRUE) + prompt("Force Processing") + interest(3) + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + prompt("Alarm Status") + initial("UDF") + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + } + field(ACKS, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + menu(menuYesNo) + special(SPC_NOMOD) + interest(2) + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + } + field(DISS, DBF_MENU) { + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + special(SPC_NOMOD) + interest(1) + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + special(SPC_NOMOD) + interest(1) + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + extra("struct processNotify *ppn") + prompt("pprocessNotify") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + special(SPC_NOMOD) + interest(4) + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + special(SPC_NOMOD) + interest(4) + } + field(RSET, DBF_NOACCESS) { + prompt("Address of RSET") + extra("struct typed_rset *rset") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct dset *dset") + prompt("DSET address") + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("void *dpvt") + prompt("Device Private") + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + menu(menuPriority) + special(SPC_SCAN) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + prompt("Undefined") + pp(TRUE) + initial("1") + interest(1) + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Undefined Alarm Sevrty") + initial("INVALID") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + special(SPC_NOMOD) + interest(2) + } + field(FLNK, DBF_FWDLINK) { + promptgroup("20 - Scan") + prompt("Forward Process Link") + interest(1) + } + field(VAL, DBF_LONG) { + promptgroup("50 - Output") + prompt("Desired Output") + pp(TRUE) + asl(ASL0) + } + field(OUT, DBF_OUTLINK) { + interest(1) + promptgroup("50 - Output") + prompt("Output Specification") + } + field(DOL, DBF_INLINK) { + promptgroup("40 - Input") + prompt("Desired Output Loc") + interest(1) + } + field(OMSL, DBF_MENU) { + menu(menuOmsl) + interest(1) + prompt("Output Mode Select") + promptgroup("50 - Output") + } + field(EGU, DBF_STRING) { + prop(YES) + promptgroup("80 - Display") + prompt("Engineering Units") + interest(1) + size(16) + } + field(DRVH, DBF_LONG) { + interest(1) + pp(TRUE) + prompt("Drive High Limit") + promptgroup("30 - Action") + prop(YES) + } + field(DRVL, DBF_LONG) { + interest(1) + promptgroup("30 - Action") + prop(YES) + pp(TRUE) + prompt("Drive Low Limit") + } + field(HOPR, DBF_LONG) { + interest(1) + promptgroup("80 - Display") + prop(YES) + prompt("High Operating Range") + } + field(LOPR, DBF_LONG) { + interest(1) + prompt("Low Operating Range") + promptgroup("80 - Display") + prop(YES) + } + field(HIHI, DBF_LONG) { + pp(TRUE) + prompt("Hihi Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + interest(1) + } + field(LOLO, DBF_LONG) { + prop(YES) + promptgroup("70 - Alarm") + prompt("Lolo Alarm Limit") + pp(TRUE) + interest(1) + } + field(HIGH, DBF_LONG) { + pp(TRUE) + prompt("High Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + interest(1) + } + field(LOW, DBF_LONG) { + prompt("Low Alarm Limit") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + interest(1) + } + field(HHSV, DBF_MENU) { + pp(TRUE) + prompt("Hihi Severity") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LLSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Lolo Severity") + pp(TRUE) + } + field(HSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("High Severity") + pp(TRUE) + promptgroup("70 - Alarm") + } + field(LSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Low Severity") + pp(TRUE) + } + field(HYST, DBF_LONG) { + interest(1) + promptgroup("70 - Alarm") + prompt("Alarm Deadband") + } + field(ADEL, DBF_LONG) { + prompt("Archive Deadband") + promptgroup("80 - Display") + interest(1) + } + field(MDEL, DBF_LONG) { + interest(1) + promptgroup("80 - Display") + prompt("Monitor Deadband") + } + field(LALM, DBF_LONG) { + interest(3) + special(SPC_NOMOD) + prompt("Last Value Alarmed") + } + field(ALST, DBF_LONG) { + prompt("Last Value Archived") + special(SPC_NOMOD) + interest(3) + } + field(MLST, DBF_LONG) { + interest(3) + special(SPC_NOMOD) + prompt("Last Val Monitored") + } + field(SIOL, DBF_OUTLINK) { + prompt("Sim Output Specifctn") + promptgroup("90 - Simulate") + interest(1) + } + field(SIML, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Sim Mode Location") + interest(1) + } + field(SIMM, DBF_MENU) { + menu(menuYesNo) + special(SPC_MOD) + interest(1) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + prompt("Sim mode Alarm Svrty") + promptgroup("90 - Simulate") + menu(menuAlarmSevr) + interest(2) + } + field(OLDSIMM, DBF_MENU) { + interest(4) + special(SPC_NOMOD) + menu(menuSimm) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + menu(menuScan) + interest(1) + initial("65535") + prompt("Sim. Mode Scan") + promptgroup("90 - Simulate") + } + field(SDLY, DBF_DOUBLE) { + promptgroup("90 - Simulate") + prompt("Sim. Mode Async Delay") + initial("-1.0") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Sim. Mode Private") + extra("epicsCallback *simpvt") + } + field(IVOA, DBF_MENU) { + menu(menuIvoa) + interest(2) + prompt("INVALID output action") + promptgroup("50 - Output") + } + field(IVOV, DBF_LONG) { + interest(2) + prompt("INVALID output value") + promptgroup("50 - Output") + } +} +device(longout, CONSTANT, devLoSoft, "Soft Channel") +device(longout, CONSTANT, devLoSoftCallback, "Async Soft Channel") +device(longout, INST_IO, asynLoInt32, "asynInt32") +device(longout, INST_IO, asynLoUInt32Digital, "asynUInt32Digital") +recordtype(mbbi) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + size(61) + special(SPC_NOMOD) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + promptgroup("10 - Common") + prompt("Descriptor") + size(41) + } + field(ASG, DBF_STRING) { + size(29) + special(SPC_AS) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + interest(1) + menu(menuScan) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + prompt("Event Name") + promptgroup("20 - Scan") + special(SPC_SCAN) + size(40) + interest(1) + } + field(TSE, DBF_SHORT) { + prompt("Time Stamp Event") + promptgroup("20 - Scan") + interest(1) + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Scanning Disable") + } + field(MLOK, DBF_NOACCESS) { + prompt("Monitor lock") + extra("epicsMutexId mlok") + special(SPC_NOMOD) + interest(4) + } + field(MLIS, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + prompt("Alarm Status") + initial("UDF") + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(NSTA, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + interest(2) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + } + field(ACKT, DBF_MENU) { + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + } + field(DISS, DBF_MENU) { + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + special(SPC_NOMOD) + interest(1) + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + special(SPC_NOMOD) + interest(1) + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + special(SPC_NOMOD) + interest(1) + } + field(ASP, DBF_NOACCESS) { + extra("struct asgMember *asp") + prompt("Access Security Pvt") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + extra("struct processNotify *ppn") + prompt("pprocessNotify") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + special(SPC_NOMOD) + interest(4) + } + field(SPVT, DBF_NOACCESS) { + prompt("Scan Private") + extra("struct scan_element *spvt") + special(SPC_NOMOD) + interest(4) + } + field(RSET, DBF_NOACCESS) { + prompt("Address of RSET") + extra("struct typed_rset *rset") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct dset *dset") + prompt("DSET address") + } + field(DPVT, DBF_NOACCESS) { + extra("void *dpvt") + prompt("Device Private") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + } + field(LSET, DBF_NOACCESS) { + extra("struct lockRecord *lset") + prompt("Lock Set") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + menu(menuPriority) + special(SPC_SCAN) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + interest(1) + promptgroup("10 - Common") + pp(TRUE) + initial("1") + prompt("Undefined") + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Undefined Alarm Sevrty") + initial("INVALID") + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + special(SPC_NOMOD) + interest(2) + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_ENUM) { + promptgroup("40 - Input") + prompt("Current Value") + pp(TRUE) + asl(ASL0) + } + field(NOBT, DBF_USHORT) { + special(SPC_NOMOD) + interest(1) + prompt("Number of Bits") + promptgroup("40 - Input") + } + field(INP, DBF_INLINK) { + interest(1) + prompt("Input Specification") + promptgroup("40 - Input") + } + field(ZRVL, DBF_ULONG) { + promptgroup("41 - Input 0-7") + special(SPC_MOD) + prompt("Zero Value") + pp(TRUE) + interest(1) + base(HEX) + } + field(ONVL, DBF_ULONG) { + base(HEX) + interest(1) + prompt("One Value") + pp(TRUE) + special(SPC_MOD) + promptgroup("41 - Input 0-7") + } + field(TWVL, DBF_ULONG) { + base(HEX) + interest(1) + pp(TRUE) + prompt("Two Value") + special(SPC_MOD) + promptgroup("41 - Input 0-7") + } + field(THVL, DBF_ULONG) { + special(SPC_MOD) + promptgroup("41 - Input 0-7") + interest(1) + base(HEX) + prompt("Three Value") + pp(TRUE) + } + field(FRVL, DBF_ULONG) { + interest(1) + base(HEX) + pp(TRUE) + prompt("Four Value") + special(SPC_MOD) + promptgroup("41 - Input 0-7") + } + field(FVVL, DBF_ULONG) { + promptgroup("41 - Input 0-7") + special(SPC_MOD) + pp(TRUE) + prompt("Five Value") + base(HEX) + interest(1) + } + field(SXVL, DBF_ULONG) { + interest(1) + base(HEX) + prompt("Six Value") + pp(TRUE) + special(SPC_MOD) + promptgroup("41 - Input 0-7") + } + field(SVVL, DBF_ULONG) { + promptgroup("41 - Input 0-7") + special(SPC_MOD) + prompt("Seven Value") + pp(TRUE) + base(HEX) + interest(1) + } + field(EIVL, DBF_ULONG) { + special(SPC_MOD) + promptgroup("42 - Input 8-15") + interest(1) + base(HEX) + prompt("Eight Value") + pp(TRUE) + } + field(NIVL, DBF_ULONG) { + base(HEX) + interest(1) + pp(TRUE) + prompt("Nine Value") + special(SPC_MOD) + promptgroup("42 - Input 8-15") + } + field(TEVL, DBF_ULONG) { + pp(TRUE) + prompt("Ten Value") + interest(1) + base(HEX) + promptgroup("42 - Input 8-15") + special(SPC_MOD) + } + field(ELVL, DBF_ULONG) { + base(HEX) + interest(1) + pp(TRUE) + prompt("Eleven Value") + special(SPC_MOD) + promptgroup("42 - Input 8-15") + } + field(TVVL, DBF_ULONG) { + base(HEX) + interest(1) + prompt("Twelve Value") + pp(TRUE) + special(SPC_MOD) + promptgroup("42 - Input 8-15") + } + field(TTVL, DBF_ULONG) { + special(SPC_MOD) + promptgroup("42 - Input 8-15") + interest(1) + base(HEX) + prompt("Thirteen Value") + pp(TRUE) + } + field(FTVL, DBF_ULONG) { + special(SPC_MOD) + promptgroup("42 - Input 8-15") + interest(1) + base(HEX) + prompt("Fourteen Value") + pp(TRUE) + } + field(FFVL, DBF_ULONG) { + special(SPC_MOD) + promptgroup("42 - Input 8-15") + interest(1) + base(HEX) + pp(TRUE) + prompt("Fifteen Value") + } + field(ZRST, DBF_STRING) { + interest(1) + pp(TRUE) + prompt("Zero String") + size(26) + special(SPC_MOD) + promptgroup("81 - Display 0-7") + } + field(ONST, DBF_STRING) { + promptgroup("81 - Display 0-7") + special(SPC_MOD) + size(26) + pp(TRUE) + prompt("One String") + interest(1) + } + field(TWST, DBF_STRING) { + special(SPC_MOD) + size(26) + promptgroup("81 - Display 0-7") + interest(1) + prompt("Two String") + pp(TRUE) + } + field(THST, DBF_STRING) { + size(26) + special(SPC_MOD) + promptgroup("81 - Display 0-7") + interest(1) + pp(TRUE) + prompt("Three String") + } + field(FRST, DBF_STRING) { + prompt("Four String") + pp(TRUE) + interest(1) + promptgroup("81 - Display 0-7") + special(SPC_MOD) + size(26) + } + field(FVST, DBF_STRING) { + promptgroup("81 - Display 0-7") + size(26) + special(SPC_MOD) + prompt("Five String") + pp(TRUE) + interest(1) + } + field(SXST, DBF_STRING) { + prompt("Six String") + pp(TRUE) + interest(1) + promptgroup("81 - Display 0-7") + size(26) + special(SPC_MOD) + } + field(SVST, DBF_STRING) { + special(SPC_MOD) + size(26) + promptgroup("81 - Display 0-7") + interest(1) + prompt("Seven String") + pp(TRUE) + } + field(EIST, DBF_STRING) { + promptgroup("82 - Display 8-15") + size(26) + special(SPC_MOD) + prompt("Eight String") + pp(TRUE) + interest(1) + } + field(NIST, DBF_STRING) { + special(SPC_MOD) + size(26) + promptgroup("82 - Display 8-15") + interest(1) + prompt("Nine String") + pp(TRUE) + } + field(TEST, DBF_STRING) { + special(SPC_MOD) + size(26) + promptgroup("82 - Display 8-15") + interest(1) + prompt("Ten String") + pp(TRUE) + } + field(ELST, DBF_STRING) { + promptgroup("82 - Display 8-15") + special(SPC_MOD) + size(26) + prompt("Eleven String") + pp(TRUE) + interest(1) + } + field(TVST, DBF_STRING) { + interest(1) + pp(TRUE) + prompt("Twelve String") + size(26) + special(SPC_MOD) + promptgroup("82 - Display 8-15") + } + field(TTST, DBF_STRING) { + special(SPC_MOD) + size(26) + promptgroup("82 - Display 8-15") + interest(1) + prompt("Thirteen String") + pp(TRUE) + } + field(FTST, DBF_STRING) { + size(26) + special(SPC_MOD) + promptgroup("82 - Display 8-15") + interest(1) + prompt("Fourteen String") + pp(TRUE) + } + field(FFST, DBF_STRING) { + interest(1) + pp(TRUE) + prompt("Fifteen String") + size(26) + special(SPC_MOD) + promptgroup("82 - Display 8-15") + } + field(ZRSV, DBF_MENU) { + prompt("State Zero Severity") + pp(TRUE) + promptgroup("71 - Alarm 0-7") + menu(menuAlarmSevr) + interest(1) + } + field(ONSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("71 - Alarm 0-7") + prompt("State One Severity") + pp(TRUE) + } + field(TWSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("State Two Severity") + pp(TRUE) + promptgroup("71 - Alarm 0-7") + } + field(THSV, DBF_MENU) { + pp(TRUE) + prompt("State Three Severity") + promptgroup("71 - Alarm 0-7") + menu(menuAlarmSevr) + interest(1) + } + field(FRSV, DBF_MENU) { + promptgroup("71 - Alarm 0-7") + pp(TRUE) + prompt("State Four Severity") + interest(1) + menu(menuAlarmSevr) + } + field(FVSV, DBF_MENU) { + pp(TRUE) + prompt("State Five Severity") + promptgroup("71 - Alarm 0-7") + menu(menuAlarmSevr) + interest(1) + } + field(SXSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("State Six Severity") + promptgroup("71 - Alarm 0-7") + } + field(SVSV, DBF_MENU) { + promptgroup("71 - Alarm 0-7") + prompt("State Seven Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(EISV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("State Eight Severity") + pp(TRUE) + promptgroup("72 - Alarm 8-15") + } + field(NISV, DBF_MENU) { + promptgroup("72 - Alarm 8-15") + prompt("State Nine Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(TESV, DBF_MENU) { + promptgroup("72 - Alarm 8-15") + prompt("State Ten Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(ELSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("State Eleven Severity") + promptgroup("72 - Alarm 8-15") + } + field(TVSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("72 - Alarm 8-15") + pp(TRUE) + prompt("State Twelve Severity") + } + field(TTSV, DBF_MENU) { + promptgroup("72 - Alarm 8-15") + pp(TRUE) + prompt("State Thirteen Sevr") + interest(1) + menu(menuAlarmSevr) + } + field(FTSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("State Fourteen Sevr") + promptgroup("72 - Alarm 8-15") + } + field(FFSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("72 - Alarm 8-15") + prompt("State Fifteen Severity") + pp(TRUE) + } + field(AFTC, DBF_DOUBLE) { + prompt("Alarm Filter Time Constant") + promptgroup("70 - Alarm") + interest(1) + } + field(AFVL, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Alarm Filter Value") + } + field(UNSV, DBF_MENU) { + prompt("Unknown State Severity") + pp(TRUE) + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(COSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Change of State Svr") + pp(TRUE) + } + field(RVAL, DBF_ULONG) { + pp(TRUE) + prompt("Raw Value") + } + field(ORAW, DBF_ULONG) { + prompt("Prev Raw Value") + special(SPC_NOMOD) + interest(3) + } + field(MASK, DBF_ULONG) { + prompt("Hardware Mask") + interest(1) + special(SPC_NOMOD) + } + field(MLST, DBF_USHORT) { + interest(3) + special(SPC_NOMOD) + prompt("Last Value Monitored") + } + field(LALM, DBF_USHORT) { + prompt("Last Value Alarmed") + interest(3) + special(SPC_NOMOD) + } + field(SDEF, DBF_SHORT) { + special(SPC_NOMOD) + interest(3) + prompt("States Defined") + } + field(SHFT, DBF_USHORT) { + promptgroup("40 - Input") + prompt("Shift") + interest(1) + } + field(SIOL, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Input Link") + interest(1) + } + field(SVAL, DBF_ULONG) { + prompt("Simulation Value") + } + field(SIML, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + interest(1) + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + interest(1) + menu(menuSimm) + special(SPC_MOD) + } + field(SIMS, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + promptgroup("90 - Simulate") + prompt("Simulation Mode Severity") + } + field(OLDSIMM, DBF_MENU) { + menu(menuSimm) + special(SPC_NOMOD) + interest(4) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + prompt("Sim. Mode Scan") + initial("65535") + promptgroup("90 - Simulate") + menu(menuScan) + interest(1) + } + field(SDLY, DBF_DOUBLE) { + promptgroup("90 - Simulate") + initial("-1.0") + prompt("Sim. Mode Async Delay") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Sim. Mode Private") + extra("epicsCallback *simpvt") + } +} +device(mbbi, CONSTANT, devMbbiSoft, "Soft Channel") +device(mbbi, CONSTANT, devMbbiSoftRaw, "Raw Soft Channel") +device(mbbi, CONSTANT, devMbbiSoftCallback, "Async Soft Channel") +device(mbbi, INST_IO, asynMbbiInt32, "asynInt32") +device(mbbi, INST_IO, asynMbbiUInt32Digital, "asynUInt32Digital") +recordtype(histogram) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + special(SPC_NOMOD) + size(61) + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + special(SPC_SCAN) + menu(menuScan) + interest(1) + prompt("Scan Mechanism") + promptgroup("20 - Scan") + } + field(PINI, DBF_MENU) { + interest(1) + menu(menuPini) + promptgroup("20 - Scan") + prompt("Process at iocInit") + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + prompt("Event Name") + promptgroup("20 - Scan") + special(SPC_SCAN) + size(40) + interest(1) + } + field(TSE, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Time Stamp Event") + interest(1) + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + initial("1") + prompt("Disable Value") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor List") + extra("ELLLIST mlis") + } + field(BKLNK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + pp(TRUE) + prompt("Force Processing") + interest(3) + } + field(STAT, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + prompt("Alarm Status") + initial("UDF") + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + } + field(ACKS, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuYesNo) + interest(2) + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + } + field(DISS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + prompt("pprocessNotify") + extra("struct processNotify *ppn") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + interest(4) + special(SPC_NOMOD) + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + special(SPC_NOMOD) + interest(4) + } + field(DSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + menu(menuPriority) + special(SPC_SCAN) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + initial("1") + pp(TRUE) + prompt("Undefined") + interest(1) + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + } + field(TIME, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Forward Process Link") + } + field(VAL, DBF_NOACCESS) { + extra("void * val") + prompt("Value") + asl(ASL0) + special(SPC_DBADDR) + } + field(NELM, DBF_USHORT) { + special(SPC_NOMOD) + interest(1) + initial("1") + prompt("Num of Array Elements") + promptgroup("30 - Action") + } + field(CSTA, DBF_SHORT) { + interest(1) + special(SPC_NOMOD) + prompt("Collection Status") + initial("1") + } + field(CMD, DBF_MENU) { + menu(histogramCMD) + asl(ASL0) + special(SPC_CALC) + interest(1) + prompt("Collection Control") + } + field(ULIM, DBF_DOUBLE) { + special(SPC_RESET) + interest(1) + prompt("Upper Signal Limit") + promptgroup("30 - Action") + prop(YES) + } + field(LLIM, DBF_DOUBLE) { + special(SPC_RESET) + interest(1) + prompt("Lower Signal Limit ") + prop(YES) + promptgroup("30 - Action") + } + field(WDTH, DBF_DOUBLE) { + prompt("Element Width") + special(SPC_NOMOD) + interest(3) + } + field(SGNL, DBF_DOUBLE) { + special(SPC_MOD) + prompt("Signal Value") + } + field(PREC, DBF_SHORT) { + interest(1) + promptgroup("80 - Display") + prop(YES) + prompt("Display Precision") + } + field(SVL, DBF_INLINK) { + interest(1) + promptgroup("40 - Input") + prompt("Signal Value Location") + } + field(BPTR, DBF_NOACCESS) { + prompt("Buffer Pointer") + extra("epicsUInt32 *bptr") + interest(4) + special(SPC_NOMOD) + } + field(WDOG, DBF_NOACCESS) { + extra("void * wdog") + prompt("Watchdog callback") + interest(4) + special(SPC_NOMOD) + } + field(MDEL, DBF_SHORT) { + prompt("Monitor Count Deadband") + promptgroup("80 - Display") + interest(1) + } + field(MCNT, DBF_SHORT) { + interest(3) + special(SPC_NOMOD) + prompt("Counts Since Monitor") + } + field(SDEL, DBF_DOUBLE) { + special(SPC_RESET) + interest(1) + prompt("Monitor Seconds Dband") + promptgroup("80 - Display") + } + field(SIOL, DBF_INLINK) { + interest(1) + promptgroup("90 - Simulate") + prompt("Simulation Input Link") + } + field(SVAL, DBF_DOUBLE) { + prompt("Simulation Value") + } + field(SIML, DBF_INLINK) { + interest(1) + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + special(SPC_MOD) + menu(menuYesNo) + interest(1) + } + field(SIMS, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + promptgroup("90 - Simulate") + prompt("Simulation Mode Severity") + } + field(OLDSIMM, DBF_MENU) { + prompt("Prev. Simulation Mode") + special(SPC_NOMOD) + menu(menuSimm) + interest(4) + } + field(SSCN, DBF_MENU) { + menu(menuScan) + interest(1) + initial("65535") + prompt("Sim. Mode Scan") + promptgroup("90 - Simulate") + } + field(SDLY, DBF_DOUBLE) { + interest(2) + prompt("Sim. Mode Async Delay") + initial("-1.0") + promptgroup("90 - Simulate") + } + field(SIMPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + } + field(HOPR, DBF_ULONG) { + interest(1) + prompt("High Operating Range") + promptgroup("80 - Display") + prop(YES) + } + field(LOPR, DBF_ULONG) { + interest(1) + prompt("Low Operating Range") + promptgroup("80 - Display") + prop(YES) + } +} +device(histogram, CONSTANT, devHistogramSoft, "Soft Channel") +recordtype(stringout) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + size(61) + special(SPC_NOMOD) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + promptgroup("10 - Common") + prompt("Descriptor") + size(41) + } + field(ASG, DBF_STRING) { + special(SPC_AS) + size(29) + promptgroup("10 - Common") + prompt("Access Security Group") + } + field(SCAN, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scan Mechanism") + interest(1) + special(SPC_SCAN) + menu(menuScan) + } + field(PINI, DBF_MENU) { + interest(1) + menu(menuPini) + promptgroup("20 - Scan") + prompt("Process at iocInit") + } + field(PHAS, DBF_SHORT) { + special(SPC_SCAN) + interest(1) + prompt("Scan Phase") + promptgroup("20 - Scan") + } + field(EVNT, DBF_STRING) { + size(40) + special(SPC_SCAN) + interest(1) + prompt("Event Name") + promptgroup("20 - Scan") + } + field(TSE, DBF_SHORT) { + interest(1) + prompt("Time Stamp Event") + promptgroup("20 - Scan") + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + prompt("Disable Value") + initial("1") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + prompt("Monitor lock") + extra("epicsMutexId mlok") + interest(4) + special(SPC_NOMOD) + } + field(MLIS, DBF_NOACCESS) { + extra("ELLLIST mlis") + prompt("Monitor List") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + prompt("Alarm Status") + initial("UDF") + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + menu(menuAlarmStat) + special(SPC_NOMOD) + interest(2) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + } + field(ACKS, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + menu(menuYesNo) + special(SPC_NOMOD) + interest(2) + } + field(DISS, DBF_MENU) { + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LCNT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(2) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + special(SPC_NOMOD) + interest(1) + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + special(SPC_NOMOD) + interest(4) + } + field(SPVT, DBF_NOACCESS) { + prompt("Scan Private") + extra("struct scan_element *spvt") + special(SPC_NOMOD) + interest(4) + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of RSET") + extra("struct typed_rset *rset") + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + special(SPC_NOMOD) + interest(4) + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuPriority) + promptgroup("20 - Scan") + prompt("Scheduling Priority") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + pp(TRUE) + initial("1") + prompt("Undefined") + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Undefined Alarm Sevrty") + initial("INVALID") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + special(SPC_NOMOD) + interest(2) + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_STRING) { + size(40) + asl(ASL0) + promptgroup("50 - Output") + prompt("Current Value") + pp(TRUE) + } + field(OVAL, DBF_STRING) { + interest(3) + special(SPC_NOMOD) + size(40) + prompt("Previous Value") + } + field(DOL, DBF_INLINK) { + prompt("Desired Output Loc") + promptgroup("40 - Input") + interest(1) + } + field(OMSL, DBF_MENU) { + prompt("Output Mode Select") + promptgroup("50 - Output") + menu(menuOmsl) + interest(1) + } + field(OUT, DBF_OUTLINK) { + interest(1) + promptgroup("50 - Output") + prompt("Output Specification") + } + field(MPST, DBF_MENU) { + promptgroup("80 - Display") + prompt("Post Value Monitors") + interest(1) + menu(stringoutPOST) + } + field(APST, DBF_MENU) { + menu(stringoutPOST) + interest(1) + prompt("Post Archive Monitors") + promptgroup("80 - Display") + } + field(SIOL, DBF_OUTLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Output Link") + interest(1) + } + field(SIML, DBF_INLINK) { + interest(1) + prompt("Simulation Mode Link") + promptgroup("90 - Simulate") + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + menu(menuYesNo) + special(SPC_MOD) + interest(1) + } + field(SIMS, DBF_MENU) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Severity") + interest(2) + menu(menuAlarmSevr) + } + field(OLDSIMM, DBF_MENU) { + prompt("Prev. Simulation Mode") + interest(4) + special(SPC_NOMOD) + menu(menuSimm) + } + field(SSCN, DBF_MENU) { + promptgroup("90 - Simulate") + initial("65535") + prompt("Sim. Mode Scan") + interest(1) + menu(menuScan) + } + field(SDLY, DBF_DOUBLE) { + interest(2) + promptgroup("90 - Simulate") + prompt("Sim. Mode Async Delay") + initial("-1.0") + } + field(SIMPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + } + field(IVOA, DBF_MENU) { + prompt("INVALID output action") + promptgroup("50 - Output") + menu(menuIvoa) + interest(2) + } + field(IVOV, DBF_STRING) { + interest(2) + size(40) + promptgroup("50 - Output") + prompt("INVALID output value") + } +} +device(stringout, CONSTANT, devSoSoft, "Soft Channel") +device(stringout, CONSTANT, devSoSoftCallback, "Async Soft Channel") +device(stringout, INST_IO, devSoStdio, "stdio") +device(stringout, INST_IO, asynSoOctetWrite, "asynOctetWrite") +recordtype(seq) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + promptgroup("10 - Common") + prompt("Descriptor") + size(41) + } + field(ASG, DBF_STRING) { + prompt("Access Security Group") + promptgroup("10 - Common") + size(29) + special(SPC_AS) + } + field(SCAN, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuScan) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + prompt("Scan Phase") + promptgroup("20 - Scan") + special(SPC_SCAN) + interest(1) + } + field(EVNT, DBF_STRING) { + promptgroup("20 - Scan") + prompt("Event Name") + interest(1) + size(40) + special(SPC_SCAN) + } + field(TSE, DBF_SHORT) { + prompt("Time Stamp Event") + promptgroup("20 - Scan") + interest(1) + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Monitor lock") + extra("epicsMutexId mlok") + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + pp(TRUE) + prompt("Force Processing") + interest(3) + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + } + field(ACKT, DBF_MENU) { + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + special(SPC_NOMOD) + menu(menuYesNo) + interest(2) + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + special(SPC_NOMOD) + interest(2) + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + interest(1) + special(SPC_NOMOD) + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + special(SPC_NOMOD) + interest(1) + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + special(SPC_NOMOD) + interest(1) + } + field(ASP, DBF_NOACCESS) { + prompt("Access Security Pvt") + extra("struct asgMember *asp") + special(SPC_NOMOD) + interest(4) + } + field(PPN, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + interest(4) + special(SPC_NOMOD) + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct scan_element *spvt") + prompt("Scan Private") + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct typed_rset *rset") + prompt("Address of RSET") + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + interest(4) + special(SPC_NOMOD) + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuPriority) + promptgroup("20 - Scan") + prompt("Scheduling Priority") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + interest(1) + promptgroup("10 - Common") + prompt("Undefined") + pp(TRUE) + initial("1") + } + field(UDFS, DBF_MENU) { + prompt("Undefined Alarm Sevrty") + initial("INVALID") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(TIME, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_LONG) { + prompt("Used to trigger") + pp(TRUE) + asl(ASL0) + } + field(SELM, DBF_MENU) { + promptgroup("30 - Action") + prompt("Select Mechanism") + interest(1) + menu(seqSELM) + } + field(SELN, DBF_USHORT) { + prompt("Link Selection") + initial("1") + interest(1) + } + field(SELL, DBF_INLINK) { + prompt("Link Selection Loc") + promptgroup("30 - Action") + interest(1) + } + field(OFFS, DBF_SHORT) { + interest(1) + prompt("Offset for Specified") + initial("0") + promptgroup("30 - Action") + } + field(SHFT, DBF_SHORT) { + interest(1) + promptgroup("30 - Action") + prompt("Shift for Mask mode") + initial("-1") + } + field(OLDN, DBF_USHORT) { + interest(4) + prompt("Old Selection") + } + field(PREC, DBF_SHORT) { + promptgroup("80 - Display") + prompt("Display Precision") + interest(1) + } + field(DLY0, DBF_DOUBLE) { + promptgroup("41 - Link 0-7") + prompt("Delay 0") + interest(1) + } + field(DOL0, DBF_INLINK) { + promptgroup("41 - Link 0-7") + prompt("Input link 0") + interest(1) + } + field(DO0, DBF_DOUBLE) { + interest(1) + prompt("Value 0") + } + field(LNK0, DBF_OUTLINK) { + interest(1) + prompt("Output Link 0") + promptgroup("41 - Link 0-7") + } + field(DLY1, DBF_DOUBLE) { + interest(1) + promptgroup("41 - Link 0-7") + prompt("Delay 1") + } + field(DOL1, DBF_INLINK) { + interest(1) + prompt("Input link1") + promptgroup("41 - Link 0-7") + } + field(DO1, DBF_DOUBLE) { + interest(1) + prompt("Value 1") + } + field(LNK1, DBF_OUTLINK) { + prompt("Output Link 1") + promptgroup("41 - Link 0-7") + interest(1) + } + field(DLY2, DBF_DOUBLE) { + interest(1) + promptgroup("41 - Link 0-7") + prompt("Delay 2") + } + field(DOL2, DBF_INLINK) { + interest(1) + prompt("Input link 2") + promptgroup("41 - Link 0-7") + } + field(DO2, DBF_DOUBLE) { + interest(1) + prompt("Value 2") + } + field(LNK2, DBF_OUTLINK) { + prompt("Output Link 2") + promptgroup("41 - Link 0-7") + interest(1) + } + field(DLY3, DBF_DOUBLE) { + prompt("Delay 3") + promptgroup("41 - Link 0-7") + interest(1) + } + field(DOL3, DBF_INLINK) { + promptgroup("41 - Link 0-7") + prompt("Input link 3") + interest(1) + } + field(DO3, DBF_DOUBLE) { + interest(1) + prompt("Value 3") + } + field(LNK3, DBF_OUTLINK) { + interest(1) + prompt("Output Link 3") + promptgroup("41 - Link 0-7") + } + field(DLY4, DBF_DOUBLE) { + prompt("Delay 4") + promptgroup("41 - Link 0-7") + interest(1) + } + field(DOL4, DBF_INLINK) { + interest(1) + promptgroup("41 - Link 0-7") + prompt("Input link 4") + } + field(DO4, DBF_DOUBLE) { + prompt("Value 4") + interest(1) + } + field(LNK4, DBF_OUTLINK) { + promptgroup("41 - Link 0-7") + prompt("Output Link 4") + interest(1) + } + field(DLY5, DBF_DOUBLE) { + interest(1) + prompt("Delay 5") + promptgroup("41 - Link 0-7") + } + field(DOL5, DBF_INLINK) { + prompt("Input link 5") + promptgroup("41 - Link 0-7") + interest(1) + } + field(DO5, DBF_DOUBLE) { + prompt("Value 5") + interest(1) + } + field(LNK5, DBF_OUTLINK) { + prompt("Output Link 5") + promptgroup("41 - Link 0-7") + interest(1) + } + field(DLY6, DBF_DOUBLE) { + promptgroup("41 - Link 0-7") + prompt("Delay 6") + interest(1) + } + field(DOL6, DBF_INLINK) { + promptgroup("41 - Link 0-7") + prompt("Input link 6") + interest(1) + } + field(DO6, DBF_DOUBLE) { + interest(1) + prompt("Value 6") + } + field(LNK6, DBF_OUTLINK) { + interest(1) + promptgroup("41 - Link 0-7") + prompt("Output Link 6") + } + field(DLY7, DBF_DOUBLE) { + promptgroup("41 - Link 0-7") + prompt("Delay 7") + interest(1) + } + field(DOL7, DBF_INLINK) { + promptgroup("41 - Link 0-7") + prompt("Input link 7") + interest(1) + } + field(DO7, DBF_DOUBLE) { + interest(1) + prompt("Value 7") + } + field(LNK7, DBF_OUTLINK) { + interest(1) + prompt("Output Link 7") + promptgroup("41 - Link 0-7") + } + field(DLY8, DBF_DOUBLE) { + interest(1) + promptgroup("42 - Link 8-F") + prompt("Delay 8") + } + field(DOL8, DBF_INLINK) { + interest(1) + promptgroup("42 - Link 8-F") + prompt("Input link 8") + } + field(DO8, DBF_DOUBLE) { + prompt("Value 8") + interest(1) + } + field(LNK8, DBF_OUTLINK) { + prompt("Output Link 8") + promptgroup("42 - Link 8-F") + interest(1) + } + field(DLY9, DBF_DOUBLE) { + interest(1) + prompt("Delay 9") + promptgroup("42 - Link 8-F") + } + field(DOL9, DBF_INLINK) { + interest(1) + promptgroup("42 - Link 8-F") + prompt("Input link 9") + } + field(DO9, DBF_DOUBLE) { + interest(1) + prompt("Value 9") + } + field(LNK9, DBF_OUTLINK) { + interest(1) + prompt("Output Link 9") + promptgroup("42 - Link 8-F") + } + field(DLYA, DBF_DOUBLE) { + promptgroup("42 - Link 8-F") + prompt("Delay 10") + interest(1) + } + field(DOLA, DBF_INLINK) { + interest(1) + promptgroup("42 - Link 8-F") + prompt("Input link 10") + } + field(DOA, DBF_DOUBLE) { + prompt("Value 10") + interest(1) + } + field(LNKA, DBF_OUTLINK) { + interest(1) + promptgroup("42 - Link 8-F") + prompt("Output Link 10") + } + field(DLYB, DBF_DOUBLE) { + prompt("Delay 11") + promptgroup("42 - Link 8-F") + interest(1) + } + field(DOLB, DBF_INLINK) { + interest(1) + prompt("Input link 11") + promptgroup("42 - Link 8-F") + } + field(DOB, DBF_DOUBLE) { + prompt("Value 11") + interest(1) + } + field(LNKB, DBF_OUTLINK) { + interest(1) + prompt("Output Link 11") + promptgroup("42 - Link 8-F") + } + field(DLYC, DBF_DOUBLE) { + prompt("Delay 12") + promptgroup("42 - Link 8-F") + interest(1) + } + field(DOLC, DBF_INLINK) { + prompt("Input link 12") + promptgroup("42 - Link 8-F") + interest(1) + } + field(DOC, DBF_DOUBLE) { + interest(1) + prompt("Value 12") + } + field(LNKC, DBF_OUTLINK) { + promptgroup("42 - Link 8-F") + prompt("Output Link 12") + interest(1) + } + field(DLYD, DBF_DOUBLE) { + prompt("Delay 13") + promptgroup("42 - Link 8-F") + interest(1) + } + field(DOLD, DBF_INLINK) { + prompt("Input link 13") + promptgroup("42 - Link 8-F") + interest(1) + } + field(DOD, DBF_DOUBLE) { + interest(1) + prompt("Value 13") + } + field(LNKD, DBF_OUTLINK) { + prompt("Output Link 13") + promptgroup("42 - Link 8-F") + interest(1) + } + field(DLYE, DBF_DOUBLE) { + interest(1) + prompt("Delay 14") + promptgroup("42 - Link 8-F") + } + field(DOLE, DBF_INLINK) { + prompt("Input link 14") + promptgroup("42 - Link 8-F") + interest(1) + } + field(DOE, DBF_DOUBLE) { + interest(1) + prompt("Value 14") + } + field(LNKE, DBF_OUTLINK) { + promptgroup("42 - Link 8-F") + prompt("Output Link 14") + interest(1) + } + field(DLYF, DBF_DOUBLE) { + prompt("Delay 15") + promptgroup("42 - Link 8-F") + interest(1) + } + field(DOLF, DBF_INLINK) { + interest(1) + prompt("Input link 15") + promptgroup("42 - Link 8-F") + } + field(DOF, DBF_DOUBLE) { + interest(1) + prompt("Value 15") + } + field(LNKF, DBF_OUTLINK) { + interest(1) + prompt("Output Link 15") + promptgroup("42 - Link 8-F") + } +} +recordtype(lso) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "devSup.h" + % + %/* Declare Device Support Entry Table */ + %typedef struct lsodset { + % long number; + % DEVSUPFUN report; + % DEVSUPFUN init; + % DEVSUPFUN init_record; + % DEVSUPFUN get_ioint_info; + % DEVSUPFUN write_string; + %} lsodset; + % + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + size(41) + prompt("Descriptor") + promptgroup("10 - Common") + } + field(ASG, DBF_STRING) { + prompt("Access Security Group") + promptgroup("10 - Common") + special(SPC_AS) + size(29) + } + field(SCAN, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuScan) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + size(40) + special(SPC_SCAN) + interest(1) + prompt("Event Name") + promptgroup("20 - Scan") + } + field(TSE, DBF_SHORT) { + prompt("Time Stamp Event") + promptgroup("20 - Scan") + interest(1) + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + special(SPC_NOMOD) + interest(4) + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor List") + extra("ELLLIST mlis") + } + field(BKLNK, DBF_NOACCESS) { + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + pp(TRUE) + prompt("Force Processing") + } + field(STAT, DBF_MENU) { + initial("UDF") + prompt("Alarm Status") + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(NSTA, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + interest(2) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKT, DBF_MENU) { + prompt("Alarm Ack Transient") + initial("YES") + promptgroup("70 - Alarm") + special(SPC_NOMOD) + menu(menuYesNo) + interest(2) + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + special(SPC_NOMOD) + interest(2) + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + interest(1) + special(SPC_NOMOD) + } + field(PUTF, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + special(SPC_NOMOD) + interest(1) + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of RSET") + extra("struct typed_rset *rset") + } + field(DSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + extra("void *dpvt") + prompt("Device Private") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + } + field(LSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + menu(menuPriority) + special(SPC_SCAN) + interest(1) + prompt("Scheduling Priority") + promptgroup("20 - Scan") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + interest(1) + promptgroup("10 - Common") + prompt("Undefined") + initial("1") + pp(TRUE) + } + field(UDFS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Undefined Alarm Sevrty") + initial("INVALID") + interest(1) + menu(menuAlarmSevr) + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + pp(TRUE) + extra("char *val") + prompt("Current Value") + } + field(OVAL, DBF_NOACCESS) { + extra("char *oval") + prompt("Previous Value") + interest(3) + special(SPC_DBADDR) + } + field(SIZV, DBF_USHORT) { + promptgroup("50 - Output") + initial("41") + prompt("Size of buffers") + interest(1) + special(SPC_NOMOD) + } + field(LEN, DBF_ULONG) { + special(SPC_NOMOD) + prompt("Length of VAL") + } + field(OLEN, DBF_ULONG) { + prompt("Length of OVAL") + interest(3) + special(SPC_NOMOD) + } + field(DOL, DBF_INLINK) { + interest(1) + promptgroup("40 - Input") + prompt("Desired Output Link") + } + field(IVOA, DBF_MENU) { + interest(2) + menu(menuIvoa) + promptgroup("50 - Output") + prompt("INVALID Output Action") + } + field(IVOV, DBF_STRING) { + prompt("INVALID Output Value") + promptgroup("50 - Output") + size(40) + interest(2) + } + field(OMSL, DBF_MENU) { + promptgroup("50 - Output") + prompt("Output Mode Select") + interest(1) + menu(menuOmsl) + } + field(OUT, DBF_OUTLINK) { + interest(1) + promptgroup("50 - Output") + prompt("Output Specification") + } + field(MPST, DBF_MENU) { + interest(1) + menu(menuPost) + promptgroup("80 - Display") + prompt("Post Value Monitors") + } + field(APST, DBF_MENU) { + menu(menuPost) + interest(1) + prompt("Post Archive Monitors") + promptgroup("80 - Display") + } + field(SIML, DBF_INLINK) { + prompt("Simulation Mode link") + promptgroup("90 - Simulate") + interest(1) + } + field(SIMM, DBF_MENU) { + interest(1) + menu(menuYesNo) + special(SPC_MOD) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Severity") + interest(2) + menu(menuAlarmSevr) + } + field(SIOL, DBF_OUTLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Output Link") + interest(1) + } + field(OLDSIMM, DBF_MENU) { + interest(4) + menu(menuSimm) + special(SPC_NOMOD) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + interest(1) + menu(menuScan) + promptgroup("90 - Simulate") + prompt("Sim. Mode Scan") + initial("65535") + } + field(SDLY, DBF_DOUBLE) { + interest(2) + prompt("Sim. Mode Async Delay") + initial("-1.0") + promptgroup("90 - Simulate") + } + field(SIMPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + } +} +device(lso, CONSTANT, devLsoSoft, "Soft Channel") +device(lso, CONSTANT, devLsoSoftCallback, "Async Soft Channel") +device(lso, INST_IO, devLsoStdio, "stdio") +recordtype(int64in) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + special(SPC_NOMOD) + size(61) + } + field(DESC, DBF_STRING) { + promptgroup("10 - Common") + prompt("Descriptor") + size(41) + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + size(29) + special(SPC_AS) + } + field(SCAN, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scan Mechanism") + interest(1) + menu(menuScan) + special(SPC_SCAN) + } + field(PINI, DBF_MENU) { + menu(menuPini) + interest(1) + prompt("Process at iocInit") + promptgroup("20 - Scan") + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + prompt("Time Stamp Event") + promptgroup("20 - Scan") + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + prompt("Device Type") + promptgroup("10 - Common") + interest(1) + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + initial("1") + prompt("Disable Value") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor lock") + extra("epicsMutexId mlok") + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor List") + extra("ELLLIST mlis") + } + field(BKLNK, DBF_NOACCESS) { + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + prompt("Alarm Status") + initial("UDF") + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(NSTA, DBF_MENU) { + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + prompt("Alarm Ack Transient") + initial("YES") + promptgroup("70 - Alarm") + special(SPC_NOMOD) + menu(menuYesNo) + interest(2) + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(2) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + interest(1) + special(SPC_NOMOD) + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + special(SPC_NOMOD) + interest(1) + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + extra("struct processNotify *ppn") + prompt("pprocessNotify") + special(SPC_NOMOD) + interest(4) + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + interest(4) + special(SPC_NOMOD) + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of RSET") + extra("struct typed_rset *rset") + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + special(SPC_NOMOD) + interest(4) + } + field(LSET, DBF_NOACCESS) { + extra("struct lockRecord *lset") + prompt("Lock Set") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + prompt("Scheduling Priority") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuPriority) + interest(1) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + extra("char bkpt") + prompt("Break Point") + interest(1) + special(SPC_NOMOD) + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + prompt("Undefined") + initial("1") + pp(TRUE) + interest(1) + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Undefined Alarm Sevrty") + initial("INVALID") + } + field(TIME, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_INT64) { + asl(ASL0) + pp(TRUE) + prompt("Current value") + promptgroup("40 - Input") + } + field(INP, DBF_INLINK) { + interest(1) + promptgroup("40 - Input") + prompt("Input Specification") + } + field(EGU, DBF_STRING) { + interest(1) + size(16) + promptgroup("80 - Display") + prop(YES) + prompt("Units name") + } + field(HOPR, DBF_INT64) { + interest(1) + prompt("High Operating Range") + prop(YES) + promptgroup("80 - Display") + } + field(LOPR, DBF_INT64) { + interest(1) + prompt("Low Operating Range") + promptgroup("80 - Display") + prop(YES) + } + field(HIHI, DBF_INT64) { + interest(1) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Hihi Alarm Limit") + } + field(LOLO, DBF_INT64) { + interest(1) + pp(TRUE) + prompt("Lolo Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + } + field(HIGH, DBF_INT64) { + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("High Alarm Limit") + interest(1) + } + field(LOW, DBF_INT64) { + prop(YES) + promptgroup("70 - Alarm") + prompt("Low Alarm Limit") + pp(TRUE) + interest(1) + } + field(HHSV, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Hihi Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(LLSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + pp(TRUE) + prompt("Lolo Severity") + } + field(HSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("High Severity") + promptgroup("70 - Alarm") + } + field(LSV, DBF_MENU) { + pp(TRUE) + prompt("Low Severity") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(HYST, DBF_INT64) { + interest(1) + prompt("Alarm Deadband") + promptgroup("70 - Alarm") + } + field(AFTC, DBF_DOUBLE) { + prompt("Alarm Filter Time Constant") + promptgroup("70 - Alarm") + interest(1) + } + field(AFVL, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Alarm Filter Value") + } + field(ADEL, DBF_INT64) { + interest(1) + promptgroup("80 - Display") + prompt("Archive Deadband") + } + field(MDEL, DBF_INT64) { + prompt("Monitor Deadband") + promptgroup("80 - Display") + interest(1) + } + field(LALM, DBF_INT64) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Alarmed") + } + field(ALST, DBF_INT64) { + prompt("Last Value Archived") + interest(3) + special(SPC_NOMOD) + } + field(MLST, DBF_INT64) { + prompt("Last Val Monitored") + special(SPC_NOMOD) + interest(3) + } + field(SIOL, DBF_INLINK) { + interest(1) + prompt("Simulation Input Link") + promptgroup("90 - Simulate") + } + field(SVAL, DBF_INT64) { + prompt("Simulation Value") + } + field(SIML, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + interest(1) + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + interest(1) + special(SPC_MOD) + menu(menuYesNo) + } + field(SIMS, DBF_MENU) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Severity") + interest(2) + menu(menuAlarmSevr) + } + field(OLDSIMM, DBF_MENU) { + prompt("Prev. Simulation Mode") + special(SPC_NOMOD) + menu(menuSimm) + interest(4) + } + field(SSCN, DBF_MENU) { + initial("65535") + prompt("Sim. Mode Scan") + promptgroup("90 - Simulate") + menu(menuScan) + interest(1) + } + field(SDLY, DBF_DOUBLE) { + promptgroup("90 - Simulate") + initial("-1.0") + prompt("Sim. Mode Async Delay") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + interest(4) + special(SPC_NOMOD) + } +} +device(int64in, CONSTANT, devI64inSoft, "Soft Channel") +device(int64in, CONSTANT, devI64inSoftCallback, "Async Soft Channel") +device(int64in, INST_IO, asynInt64In, "asynInt64") +recordtype(event) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "dbScan.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + size(29) + special(SPC_AS) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + interest(1) + menu(menuScan) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + interest(1) + prompt("Time Stamp Link") + promptgroup("20 - Scan") + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + prompt("Monitor lock") + extra("epicsMutexId mlok") + interest(4) + special(SPC_NOMOD) + } + field(MLIS, DBF_NOACCESS) { + extra("ELLLIST mlis") + prompt("Monitor List") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + prompt("Force Processing") + pp(TRUE) + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKT, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + interest(2) + special(SPC_NOMOD) + menu(menuYesNo) + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + special(SPC_NOMOD) + interest(4) + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct scan_element *spvt") + prompt("Scan Private") + } + field(RSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct typed_rset *rset") + prompt("Address of RSET") + } + field(DSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Lock Set") + extra("struct lockRecord *lset") + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + special(SPC_SCAN) + menu(menuPriority) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + extra("char bkpt") + prompt("Break Point") + interest(1) + special(SPC_NOMOD) + } + field(UDF, DBF_UCHAR) { + prompt("Undefined") + initial("1") + pp(TRUE) + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Undefined Alarm Sevrty") + initial("INVALID") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + prompt("Forward Process Link") + promptgroup("20 - Scan") + interest(1) + } + field(VAL, DBF_STRING) { + special(SPC_MOD) + size(40) + asl(ASL0) + prompt("Event Name To Post") + promptgroup("40 - Input") + } + field(EPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("EVENTPVT epvt") + prompt("Event private") + } + field(INP, DBF_INLINK) { + interest(1) + promptgroup("40 - Input") + prompt("Input Specification") + } + field(SIOL, DBF_INLINK) { + interest(1) + promptgroup("90 - Simulate") + prompt("Sim Input Specifctn") + } + field(SVAL, DBF_STRING) { + size(40) + prompt("Simulation Value") + } + field(SIML, DBF_INLINK) { + prompt("Sim Mode Location") + promptgroup("90 - Simulate") + interest(1) + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + menu(menuYesNo) + special(SPC_MOD) + interest(1) + } + field(SIMS, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + promptgroup("90 - Simulate") + prompt("Sim mode Alarm Svrty") + } + field(OLDSIMM, DBF_MENU) { + interest(4) + special(SPC_NOMOD) + menu(menuSimm) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + interest(1) + menu(menuScan) + promptgroup("90 - Simulate") + initial("65535") + prompt("Sim. Mode Scan") + } + field(SDLY, DBF_DOUBLE) { + interest(2) + prompt("Sim. Mode Async Delay") + initial("-1.0") + promptgroup("90 - Simulate") + } + field(SIMPVT, DBF_NOACCESS) { + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + special(SPC_NOMOD) + interest(4) + } +} +device(event, CONSTANT, devEventSoft, "Soft Channel") +recordtype(sel) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + size(41) + prompt("Descriptor") + promptgroup("10 - Common") + } + field(ASG, DBF_STRING) { + prompt("Access Security Group") + promptgroup("10 - Common") + special(SPC_AS) + size(29) + } + field(SCAN, DBF_MENU) { + special(SPC_SCAN) + menu(menuScan) + interest(1) + prompt("Scan Mechanism") + promptgroup("20 - Scan") + } + field(PINI, DBF_MENU) { + menu(menuPini) + interest(1) + prompt("Process at iocInit") + promptgroup("20 - Scan") + } + field(PHAS, DBF_SHORT) { + prompt("Scan Phase") + promptgroup("20 - Scan") + special(SPC_SCAN) + interest(1) + } + field(EVNT, DBF_STRING) { + special(SPC_SCAN) + size(40) + interest(1) + prompt("Event Name") + promptgroup("20 - Scan") + } + field(TSE, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Time Stamp Event") + interest(1) + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + prompt("Disable Value") + initial("1") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + prompt("Monitor lock") + extra("epicsMutexId mlok") + interest(4) + special(SPC_NOMOD) + } + field(MLIS, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + pp(TRUE) + prompt("Force Processing") + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + prompt("Alarm Status") + initial("UDF") + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(NSTA, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmStat) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + } + field(ACKT, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuYesNo) + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + } + field(DISS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + } + field(LCNT, DBF_UCHAR) { + interest(2) + special(SPC_NOMOD) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + special(SPC_NOMOD) + interest(1) + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + interest(1) + special(SPC_NOMOD) + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + prompt("Access Security Pvt") + extra("struct asgMember *asp") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + extra("struct processNotify *ppn") + prompt("pprocessNotify") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + interest(4) + special(SPC_NOMOD) + } + field(RSET, DBF_NOACCESS) { + prompt("Address of RSET") + extra("struct typed_rset *rset") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + interest(4) + special(SPC_NOMOD) + } + field(DPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("void *dpvt") + prompt("Device Private") + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Lock Set") + extra("struct lockRecord *lset") + } + field(PRIO, DBF_MENU) { + menu(menuPriority) + special(SPC_SCAN) + interest(1) + prompt("Scheduling Priority") + promptgroup("20 - Scan") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + prompt("Break Point") + extra("char bkpt") + special(SPC_NOMOD) + interest(1) + } + field(UDF, DBF_UCHAR) { + prompt("Undefined") + initial("1") + pp(TRUE) + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(TIME, DBF_NOACCESS) { + interest(2) + special(SPC_NOMOD) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_DOUBLE) { + asl(ASL0) + special(SPC_NOMOD) + prompt("Result") + promptgroup("40 - Input") + } + field(SELM, DBF_MENU) { + menu(selSELM) + prompt("Select Mechanism") + promptgroup("30 - Action") + } + field(SELN, DBF_USHORT) { + prompt("Index value") + } + field(PREC, DBF_SHORT) { + promptgroup("80 - Display") + prompt("Display Precision") + interest(1) + } + field(NVL, DBF_INLINK) { + promptgroup("30 - Action") + prompt("Index Value Location") + interest(1) + } + field(INPA, DBF_INLINK) { + interest(1) + prompt("Input A") + promptgroup("41 - Input A-F") + } + field(INPB, DBF_INLINK) { + promptgroup("41 - Input A-F") + prompt("Input B") + interest(1) + } + field(INPC, DBF_INLINK) { + promptgroup("41 - Input A-F") + prompt("Input C") + interest(1) + } + field(INPD, DBF_INLINK) { + prompt("Input D") + promptgroup("41 - Input A-F") + interest(1) + } + field(INPE, DBF_INLINK) { + interest(1) + prompt("Input E") + promptgroup("41 - Input A-F") + } + field(INPF, DBF_INLINK) { + prompt("Input F") + promptgroup("41 - Input A-F") + interest(1) + } + field(INPG, DBF_INLINK) { + interest(1) + promptgroup("42 - Input G-L") + prompt("Input G") + } + field(INPH, DBF_INLINK) { + interest(1) + promptgroup("42 - Input G-L") + prompt("Input H") + } + field(INPI, DBF_INLINK) { + promptgroup("42 - Input G-L") + prompt("Input I") + interest(1) + } + field(INPJ, DBF_INLINK) { + interest(1) + promptgroup("42 - Input G-L") + prompt("Input J") + } + field(INPK, DBF_INLINK) { + interest(1) + prompt("Input K") + promptgroup("42 - Input G-L") + } + field(INPL, DBF_INLINK) { + interest(1) + prompt("Input L") + promptgroup("42 - Input G-L") + } + field(EGU, DBF_STRING) { + promptgroup("80 - Display") + prop(YES) + prompt("Engineering Units") + interest(1) + size(16) + } + field(HOPR, DBF_DOUBLE) { + prompt("High Operating Rng") + prop(YES) + promptgroup("80 - Display") + interest(1) + } + field(LOPR, DBF_DOUBLE) { + interest(1) + prompt("Low Operating Range") + prop(YES) + promptgroup("80 - Display") + } + field(HIHI, DBF_DOUBLE) { + interest(1) + prop(YES) + promptgroup("70 - Alarm") + prompt("Hihi Alarm Limit") + pp(TRUE) + } + field(LOLO, DBF_DOUBLE) { + interest(1) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Lolo Alarm Limit") + } + field(HIGH, DBF_DOUBLE) { + prompt("High Alarm Limit") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + interest(1) + } + field(LOW, DBF_DOUBLE) { + pp(TRUE) + prompt("Low Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + interest(1) + } + field(HHSV, DBF_MENU) { + prompt("Hihi Severity") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LLSV, DBF_MENU) { + pp(TRUE) + prompt("Lolo Severity") + promptgroup("70 - Alarm") + prop(YES) + menu(menuAlarmSevr) + interest(1) + } + field(HSV, DBF_MENU) { + prompt("High Severity") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + prop(YES) + promptgroup("70 - Alarm") + prompt("Low Severity") + pp(TRUE) + } + field(HYST, DBF_DOUBLE) { + promptgroup("70 - Alarm") + prompt("Alarm Deadband") + interest(1) + } + field(ADEL, DBF_DOUBLE) { + prompt("Archive Deadband") + promptgroup("80 - Display") + interest(1) + } + field(MDEL, DBF_DOUBLE) { + promptgroup("80 - Display") + prompt("Monitor Deadband") + interest(1) + } + field(A, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input A") + } + field(B, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input B") + } + field(C, DBF_DOUBLE) { + prompt("Value of Input C") + pp(TRUE) + } + field(D, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input D") + } + field(E, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input E") + } + field(F, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input F") + } + field(G, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input G") + } + field(H, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input H") + } + field(I, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input I") + } + field(J, DBF_DOUBLE) { + prompt("Value of Input J") + pp(TRUE) + } + field(K, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input K") + } + field(L, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input L") + } + field(LA, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of A") + } + field(LB, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of B") + } + field(LC, DBF_DOUBLE) { + prompt("Prev Value of C") + special(SPC_NOMOD) + interest(3) + } + field(LD, DBF_DOUBLE) { + prompt("Prev Value of D") + interest(3) + special(SPC_NOMOD) + } + field(LE, DBF_DOUBLE) { + prompt("Prev Value of E") + interest(3) + special(SPC_NOMOD) + } + field(LF, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of F") + } + field(LG, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of G") + } + field(LH, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of H") + } + field(LI, DBF_DOUBLE) { + prompt("Prev Value of I") + interest(3) + special(SPC_NOMOD) + } + field(LJ, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of J") + } + field(LK, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of K") + } + field(LL, DBF_DOUBLE) { + prompt("Prev Value of L") + special(SPC_NOMOD) + interest(3) + } + field(LALM, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Alarmed") + } + field(ALST, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Archived") + } + field(MLST, DBF_DOUBLE) { + prompt("Last Val Monitored") + special(SPC_NOMOD) + interest(3) + } + field(NLST, DBF_USHORT) { + prompt("Last Index Monitored") + interest(3) + special(SPC_NOMOD) + } +} +recordtype(sub) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %struct subRecord; + %typedef long (*SUBFUNCPTR)(struct subRecord *); + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + size(29) + special(SPC_AS) + } + field(SCAN, DBF_MENU) { + interest(1) + menu(menuScan) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + interest(1) + menu(menuPini) + promptgroup("20 - Scan") + prompt("Process at iocInit") + } + field(PHAS, DBF_SHORT) { + special(SPC_SCAN) + interest(1) + prompt("Scan Phase") + promptgroup("20 - Scan") + } + field(EVNT, DBF_STRING) { + interest(1) + special(SPC_SCAN) + size(40) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Time Stamp Event") + interest(1) + } + field(TSEL, DBF_INLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Link") + } + field(DTYP, DBF_DEVICE) { + interest(1) + promptgroup("10 - Common") + prompt("Device Type") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor lock") + extra("epicsMutexId mlok") + } + field(MLIS, DBF_NOACCESS) { + prompt("Monitor List") + extra("ELLLIST mlis") + special(SPC_NOMOD) + interest(4) + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + pp(TRUE) + prompt("Force Processing") + interest(3) + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + prompt("Alarm Status") + initial("UDF") + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + menu(menuAlarmStat) + special(SPC_NOMOD) + interest(2) + } + field(NSEV, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuYesNo) + promptgroup("70 - Alarm") + initial("YES") + prompt("Alarm Ack Transient") + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + interest(2) + special(SPC_NOMOD) + } + field(PACT, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Access Security Pvt") + extra("struct asgMember *asp") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + interest(4) + special(SPC_NOMOD) + } + field(SPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct scan_element *spvt") + prompt("Scan Private") + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + special(SPC_NOMOD) + interest(4) + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + } + field(LSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct lockRecord *lset") + prompt("Lock Set") + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + special(SPC_SCAN) + menu(menuPriority) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + prompt("Break Point") + extra("char bkpt") + interest(1) + special(SPC_NOMOD) + } + field(UDF, DBF_UCHAR) { + interest(1) + pp(TRUE) + initial("1") + prompt("Undefined") + promptgroup("10 - Common") + } + field(UDFS, DBF_MENU) { + prompt("Undefined Alarm Sevrty") + initial("INVALID") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + extra("epicsTimeStamp time") + prompt("Time") + } + field(FLNK, DBF_FWDLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Forward Process Link") + } + field(VAL, DBF_DOUBLE) { + pp(TRUE) + prompt("Result") + asl(ASL0) + } + field(INAM, DBF_STRING) { + promptgroup("30 - Action") + prompt("Init Routine Name") + interest(1) + special(SPC_NOMOD) + size(40) + } + field(SNAM, DBF_STRING) { + promptgroup("30 - Action") + prompt("Subroutine Name") + interest(1) + size(40) + special(SPC_MOD) + } + field(SADR, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("SUBFUNCPTR sadr") + prompt("Subroutine Address") + } + field(INPA, DBF_INLINK) { + interest(1) + promptgroup("41 - Input A-F") + prompt("Input A") + } + field(INPB, DBF_INLINK) { + promptgroup("41 - Input A-F") + prompt("Input B") + interest(1) + } + field(INPC, DBF_INLINK) { + prompt("Input C") + promptgroup("41 - Input A-F") + interest(1) + } + field(INPD, DBF_INLINK) { + prompt("Input D") + promptgroup("41 - Input A-F") + interest(1) + } + field(INPE, DBF_INLINK) { + prompt("Input E") + promptgroup("41 - Input A-F") + interest(1) + } + field(INPF, DBF_INLINK) { + interest(1) + promptgroup("41 - Input A-F") + prompt("Input F") + } + field(INPG, DBF_INLINK) { + interest(1) + prompt("Input G") + promptgroup("42 - Input G-L") + } + field(INPH, DBF_INLINK) { + interest(1) + promptgroup("42 - Input G-L") + prompt("Input H") + } + field(INPI, DBF_INLINK) { + prompt("Input I") + promptgroup("42 - Input G-L") + interest(1) + } + field(INPJ, DBF_INLINK) { + prompt("Input J") + promptgroup("42 - Input G-L") + interest(1) + } + field(INPK, DBF_INLINK) { + interest(1) + prompt("Input K") + promptgroup("42 - Input G-L") + } + field(INPL, DBF_INLINK) { + interest(1) + promptgroup("42 - Input G-L") + prompt("Input L") + } + field(EGU, DBF_STRING) { + size(16) + interest(1) + prompt("Engineering Units") + promptgroup("80 - Display") + prop(YES) + } + field(HOPR, DBF_DOUBLE) { + prop(YES) + promptgroup("80 - Display") + prompt("High Operating Range") + interest(1) + } + field(LOPR, DBF_DOUBLE) { + interest(1) + promptgroup("80 - Display") + prop(YES) + prompt("Low Operating Range") + } + field(HIHI, DBF_DOUBLE) { + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Hihi Alarm Limit") + interest(1) + } + field(LOLO, DBF_DOUBLE) { + interest(1) + pp(TRUE) + prompt("Lolo Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + } + field(HIGH, DBF_DOUBLE) { + pp(TRUE) + prompt("High Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + interest(1) + } + field(LOW, DBF_DOUBLE) { + pp(TRUE) + prompt("Low Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + interest(1) + } + field(PREC, DBF_SHORT) { + prompt("Display Precision") + prop(YES) + promptgroup("80 - Display") + interest(1) + } + field(BRSV, DBF_MENU) { + prompt("Bad Return Severity") + pp(TRUE) + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(HHSV, DBF_MENU) { + prop(YES) + promptgroup("70 - Alarm") + prompt("Hihi Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(LLSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + prop(YES) + promptgroup("70 - Alarm") + prompt("Lolo Severity") + pp(TRUE) + } + field(HSV, DBF_MENU) { + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("High Severity") + interest(1) + menu(menuAlarmSevr) + } + field(LSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Low Severity") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + } + field(HYST, DBF_DOUBLE) { + prompt("Alarm Deadband") + promptgroup("70 - Alarm") + interest(1) + } + field(ADEL, DBF_DOUBLE) { + prompt("Archive Deadband") + promptgroup("80 - Display") + interest(1) + } + field(MDEL, DBF_DOUBLE) { + prompt("Monitor Deadband") + promptgroup("80 - Display") + interest(1) + } + field(A, DBF_DOUBLE) { + prompt("Value of Input A") + pp(TRUE) + } + field(B, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input B") + } + field(C, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input C") + } + field(D, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input D") + } + field(E, DBF_DOUBLE) { + prompt("Value of Input E") + pp(TRUE) + } + field(F, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input F") + } + field(G, DBF_DOUBLE) { + prompt("Value of Input G") + pp(TRUE) + } + field(H, DBF_DOUBLE) { + prompt("Value of Input H") + pp(TRUE) + } + field(I, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input I") + } + field(J, DBF_DOUBLE) { + prompt("Value of Input J") + pp(TRUE) + } + field(K, DBF_DOUBLE) { + prompt("Value of Input K") + pp(TRUE) + } + field(L, DBF_DOUBLE) { + prompt("Value of Input L") + pp(TRUE) + } + field(LA, DBF_DOUBLE) { + prompt("Prev Value of A") + special(SPC_NOMOD) + interest(3) + } + field(LB, DBF_DOUBLE) { + prompt("Prev Value of B") + special(SPC_NOMOD) + interest(3) + } + field(LC, DBF_DOUBLE) { + prompt("Prev Value of C") + special(SPC_NOMOD) + interest(3) + } + field(LD, DBF_DOUBLE) { + prompt("Prev Value of D") + special(SPC_NOMOD) + interest(3) + } + field(LE, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of E") + } + field(LF, DBF_DOUBLE) { + prompt("Prev Value of F") + interest(3) + special(SPC_NOMOD) + } + field(LG, DBF_DOUBLE) { + prompt("Prev Value of G") + interest(3) + special(SPC_NOMOD) + } + field(LH, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of H") + } + field(LI, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of I") + } + field(LJ, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of J") + } + field(LK, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of K") + } + field(LL, DBF_DOUBLE) { + prompt("Prev Value of L") + special(SPC_NOMOD) + interest(3) + } + field(LALM, DBF_DOUBLE) { + prompt("Last Value Alarmed") + interest(3) + special(SPC_NOMOD) + } + field(ALST, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Archived") + } + field(MLST, DBF_DOUBLE) { + prompt("Last Value Monitored") + special(SPC_NOMOD) + interest(3) + } +} +recordtype(calcout) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "dbScan.h" + %#include "postfix.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + size(41) + promptgroup("10 - Common") + prompt("Descriptor") + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + size(29) + special(SPC_AS) + } + field(SCAN, DBF_MENU) { + interest(1) + special(SPC_SCAN) + menu(menuScan) + promptgroup("20 - Scan") + prompt("Scan Mechanism") + } + field(PINI, DBF_MENU) { + prompt("Process at iocInit") + promptgroup("20 - Scan") + menu(menuPini) + interest(1) + } + field(PHAS, DBF_SHORT) { + interest(1) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scan Phase") + } + field(EVNT, DBF_STRING) { + promptgroup("20 - Scan") + prompt("Event Name") + interest(1) + size(40) + special(SPC_SCAN) + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Link") + } + field(DTYP, DBF_DEVICE) { + prompt("Device Type") + promptgroup("10 - Common") + interest(1) + } + field(DISV, DBF_SHORT) { + initial("1") + prompt("Disable Value") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor List") + extra("ELLLIST mlis") + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + interest(2) + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKT, DBF_MENU) { + prompt("Alarm Ack Transient") + initial("YES") + promptgroup("70 - Alarm") + menu(menuYesNo) + special(SPC_NOMOD) + interest(2) + } + field(DISS, DBF_MENU) { + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + interest(2) + special(SPC_NOMOD) + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + interest(1) + special(SPC_NOMOD) + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + special(SPC_NOMOD) + interest(1) + } + field(RPRO, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + extra("struct asgMember *asp") + prompt("Access Security Pvt") + special(SPC_NOMOD) + interest(4) + } + field(PPN, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + special(SPC_NOMOD) + interest(4) + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Scan Private") + extra("struct scan_element *spvt") + } + field(RSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct typed_rset *rset") + prompt("Address of RSET") + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + special(SPC_NOMOD) + interest(4) + } + field(PRIO, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scheduling Priority") + interest(1) + special(SPC_SCAN) + menu(menuPriority) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + prompt("Undefined") + pp(TRUE) + initial("1") + interest(1) + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Undefined Alarm Sevrty") + initial("INVALID") + } + field(TIME, DBF_NOACCESS) { + extra("epicsTimeStamp time") + prompt("Time") + interest(2) + special(SPC_NOMOD) + } + field(FLNK, DBF_FWDLINK) { + promptgroup("20 - Scan") + prompt("Forward Process Link") + interest(1) + } + field(RPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Record Private") + extra("struct rpvtStruct *rpvt") + } + field(VAL, DBF_DOUBLE) { + asl(ASL0) + prompt("Result") + promptgroup("50 - Output") + } + field(PVAL, DBF_DOUBLE) { + prompt("Previous Value") + } + field(CALC, DBF_STRING) { + promptgroup("30 - Action") + special(SPC_CALC) + size(80) + initial("0") + pp(TRUE) + prompt("Calculation") + } + field(CLCV, DBF_LONG) { + prompt("CALC Valid") + interest(1) + } + field(INPA, DBF_INLINK) { + special(SPC_MOD) + interest(1) + prompt("Input A") + promptgroup("41 - Input A-F") + } + field(INPB, DBF_INLINK) { + promptgroup("41 - Input A-F") + prompt("Input B") + interest(1) + special(SPC_MOD) + } + field(INPC, DBF_INLINK) { + interest(1) + special(SPC_MOD) + promptgroup("41 - Input A-F") + prompt("Input C") + } + field(INPD, DBF_INLINK) { + interest(1) + special(SPC_MOD) + promptgroup("41 - Input A-F") + prompt("Input D") + } + field(INPE, DBF_INLINK) { + prompt("Input E") + promptgroup("41 - Input A-F") + special(SPC_MOD) + interest(1) + } + field(INPF, DBF_INLINK) { + special(SPC_MOD) + interest(1) + prompt("Input F") + promptgroup("41 - Input A-F") + } + field(INPG, DBF_INLINK) { + prompt("Input G") + promptgroup("42 - Input G-L") + special(SPC_MOD) + interest(1) + } + field(INPH, DBF_INLINK) { + promptgroup("42 - Input G-L") + prompt("Input H") + interest(1) + special(SPC_MOD) + } + field(INPI, DBF_INLINK) { + promptgroup("42 - Input G-L") + prompt("Input I") + interest(1) + special(SPC_MOD) + } + field(INPJ, DBF_INLINK) { + interest(1) + special(SPC_MOD) + promptgroup("42 - Input G-L") + prompt("Input J") + } + field(INPK, DBF_INLINK) { + special(SPC_MOD) + interest(1) + prompt("Input K") + promptgroup("42 - Input G-L") + } + field(INPL, DBF_INLINK) { + promptgroup("42 - Input G-L") + prompt("Input L") + interest(1) + special(SPC_MOD) + } + field(OUT, DBF_OUTLINK) { + prompt("Output Specification") + promptgroup("50 - Output") + special(SPC_MOD) + interest(1) + } + field(INAV, DBF_MENU) { + initial("1") + prompt("INPA PV Status") + special(SPC_NOMOD) + menu(calcoutINAV) + interest(1) + } + field(INBV, DBF_MENU) { + menu(calcoutINAV) + special(SPC_NOMOD) + interest(1) + prompt("INPB PV Status") + initial("1") + } + field(INCV, DBF_MENU) { + menu(calcoutINAV) + special(SPC_NOMOD) + interest(1) + prompt("INPC PV Status") + initial("1") + } + field(INDV, DBF_MENU) { + prompt("INPD PV Status") + initial("1") + interest(1) + special(SPC_NOMOD) + menu(calcoutINAV) + } + field(INEV, DBF_MENU) { + initial("1") + prompt("INPE PV Status") + interest(1) + menu(calcoutINAV) + special(SPC_NOMOD) + } + field(INFV, DBF_MENU) { + initial("1") + prompt("INPF PV Status") + special(SPC_NOMOD) + menu(calcoutINAV) + interest(1) + } + field(INGV, DBF_MENU) { + special(SPC_NOMOD) + menu(calcoutINAV) + interest(1) + prompt("INPG PV Status") + initial("1") + } + field(INHV, DBF_MENU) { + special(SPC_NOMOD) + menu(calcoutINAV) + interest(1) + prompt("INPH PV Status") + initial("1") + } + field(INIV, DBF_MENU) { + prompt("INPI PV Status") + initial("1") + menu(calcoutINAV) + special(SPC_NOMOD) + interest(1) + } + field(INJV, DBF_MENU) { + interest(1) + special(SPC_NOMOD) + menu(calcoutINAV) + prompt("INPJ PV Status") + initial("1") + } + field(INKV, DBF_MENU) { + interest(1) + menu(calcoutINAV) + special(SPC_NOMOD) + initial("1") + prompt("INPK PV Status") + } + field(INLV, DBF_MENU) { + initial("1") + prompt("INPL PV Status") + menu(calcoutINAV) + special(SPC_NOMOD) + interest(1) + } + field(OUTV, DBF_MENU) { + interest(1) + menu(calcoutINAV) + special(SPC_NOMOD) + prompt("OUT PV Status") + } + field(OOPT, DBF_MENU) { + menu(calcoutOOPT) + interest(1) + prompt("Output Execute Opt") + promptgroup("50 - Output") + } + field(ODLY, DBF_DOUBLE) { + promptgroup("50 - Output") + prompt("Output Execute Delay") + interest(1) + asl(ASL0) + } + field(DLYA, DBF_USHORT) { + asl(ASL0) + special(SPC_NOMOD) + prompt("Output Delay Active") + } + field(DOPT, DBF_MENU) { + promptgroup("30 - Action") + prompt("Output Data Opt") + interest(1) + menu(calcoutDOPT) + } + field(OCAL, DBF_STRING) { + prompt("Output Calculation") + pp(TRUE) + initial("0") + size(80) + special(SPC_CALC) + promptgroup("30 - Action") + } + field(OCLV, DBF_LONG) { + prompt("OCAL Valid") + interest(1) + } + field(OEVT, DBF_STRING) { + prompt("Event To Issue") + promptgroup("30 - Action") + asl(ASL0) + size(40) + special(SPC_MOD) + } + field(EPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Event private") + extra("EVENTPVT epvt") + } + field(IVOA, DBF_MENU) { + interest(2) + menu(menuIvoa) + promptgroup("50 - Output") + prompt("INVALID output action") + } + field(IVOV, DBF_DOUBLE) { + prompt("INVALID output value") + promptgroup("50 - Output") + interest(2) + } + field(EGU, DBF_STRING) { + prompt("Engineering Units") + prop(YES) + promptgroup("80 - Display") + size(16) + interest(1) + } + field(PREC, DBF_SHORT) { + prompt("Display Precision") + promptgroup("80 - Display") + prop(YES) + interest(1) + } + field(HOPR, DBF_DOUBLE) { + interest(1) + prompt("High Operating Rng") + prop(YES) + promptgroup("80 - Display") + } + field(LOPR, DBF_DOUBLE) { + interest(1) + prompt("Low Operating Range") + promptgroup("80 - Display") + prop(YES) + } + field(HIHI, DBF_DOUBLE) { + interest(1) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Hihi Alarm Limit") + } + field(LOLO, DBF_DOUBLE) { + prop(YES) + promptgroup("70 - Alarm") + prompt("Lolo Alarm Limit") + pp(TRUE) + interest(1) + } + field(HIGH, DBF_DOUBLE) { + interest(1) + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("High Alarm Limit") + } + field(LOW, DBF_DOUBLE) { + prompt("Low Alarm Limit") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + interest(1) + } + field(HHSV, DBF_MENU) { + prop(YES) + promptgroup("70 - Alarm") + prompt("Hihi Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(LLSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("Lolo Severity") + promptgroup("70 - Alarm") + prop(YES) + } + field(HSV, DBF_MENU) { + prompt("High Severity") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LSV, DBF_MENU) { + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Low Severity") + interest(1) + menu(menuAlarmSevr) + } + field(HYST, DBF_DOUBLE) { + interest(1) + promptgroup("70 - Alarm") + prompt("Alarm Deadband") + } + field(ADEL, DBF_DOUBLE) { + interest(1) + promptgroup("80 - Display") + prompt("Archive Deadband") + } + field(MDEL, DBF_DOUBLE) { + interest(1) + promptgroup("80 - Display") + prompt("Monitor Deadband") + } + field(A, DBF_DOUBLE) { + prompt("Value of Input A") + pp(TRUE) + } + field(B, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input B") + } + field(C, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input C") + } + field(D, DBF_DOUBLE) { + prompt("Value of Input D") + pp(TRUE) + } + field(E, DBF_DOUBLE) { + prompt("Value of Input E") + pp(TRUE) + } + field(F, DBF_DOUBLE) { + prompt("Value of Input F") + pp(TRUE) + } + field(G, DBF_DOUBLE) { + prompt("Value of Input G") + pp(TRUE) + } + field(H, DBF_DOUBLE) { + prompt("Value of Input H") + pp(TRUE) + } + field(I, DBF_DOUBLE) { + prompt("Value of Input I") + pp(TRUE) + } + field(J, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input J") + } + field(K, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input K") + } + field(L, DBF_DOUBLE) { + pp(TRUE) + prompt("Value of Input L") + } + field(OVAL, DBF_DOUBLE) { + asl(ASL0) + prompt("Output Value") + } + field(LA, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of A") + } + field(LB, DBF_DOUBLE) { + prompt("Prev Value of B") + special(SPC_NOMOD) + interest(3) + } + field(LC, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of C") + } + field(LD, DBF_DOUBLE) { + prompt("Prev Value of D") + interest(3) + special(SPC_NOMOD) + } + field(LE, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of E") + } + field(LF, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of F") + } + field(LG, DBF_DOUBLE) { + prompt("Prev Value of G") + interest(3) + special(SPC_NOMOD) + } + field(LH, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of H") + } + field(LI, DBF_DOUBLE) { + prompt("Prev Value of I") + interest(3) + special(SPC_NOMOD) + } + field(LJ, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Prev Value of J") + } + field(LK, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Prev Value of K") + } + field(LL, DBF_DOUBLE) { + prompt("Prev Value of L") + interest(3) + special(SPC_NOMOD) + } + field(POVL, DBF_DOUBLE) { + asl(ASL0) + prompt("Prev Value of OVAL") + } + field(LALM, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Alarmed") + } + field(ALST, DBF_DOUBLE) { + prompt("Last Value Archived") + special(SPC_NOMOD) + interest(3) + } + field(MLST, DBF_DOUBLE) { + prompt("Last Val Monitored") + special(SPC_NOMOD) + interest(3) + } + field(RPCL, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Reverse Polish Calc") + extra("char rpcl[INFIX_TO_POSTFIX_SIZE(80)]") + } + field(ORPC, DBF_NOACCESS) { + prompt("Reverse Polish OCalc") + extra("char orpc[INFIX_TO_POSTFIX_SIZE(80)]") + special(SPC_NOMOD) + interest(4) + } +} +device(calcout, CONSTANT, devCalcoutSoft, "Soft Channel") +device(calcout, CONSTANT, devCalcoutSoftCallback, "Async Soft Channel") +recordtype(ai) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + size(61) + special(SPC_NOMOD) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + prompt("Descriptor") + promptgroup("10 - Common") + size(41) + } + field(ASG, DBF_STRING) { + size(29) + special(SPC_AS) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + menu(menuScan) + special(SPC_SCAN) + interest(1) + } + field(PINI, DBF_MENU) { + menu(menuPini) + interest(1) + prompt("Process at iocInit") + promptgroup("20 - Scan") + } + field(PHAS, DBF_SHORT) { + special(SPC_SCAN) + interest(1) + prompt("Scan Phase") + promptgroup("20 - Scan") + } + field(EVNT, DBF_STRING) { + promptgroup("20 - Scan") + prompt("Event Name") + interest(1) + special(SPC_SCAN) + size(40) + } + field(TSE, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Time Stamp Event") + interest(1) + } + field(TSEL, DBF_INLINK) { + prompt("Time Stamp Link") + promptgroup("20 - Scan") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + initial("1") + prompt("Disable Value") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + special(SPC_NOMOD) + interest(4) + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + interest(4) + special(SPC_NOMOD) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + interest(3) + prompt("Force Processing") + pp(TRUE) + } + field(STAT, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + special(SPC_NOMOD) + menu(menuAlarmStat) + interest(2) + } + field(NSEV, DBF_MENU) { + prompt("New Alarm Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + } + field(ACKT, DBF_MENU) { + promptgroup("70 - Alarm") + initial("YES") + prompt("Alarm Ack Transient") + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + } + field(DISS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(LCNT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(2) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + prompt("Access Security Pvt") + extra("struct asgMember *asp") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + interest(4) + special(SPC_NOMOD) + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + special(SPC_NOMOD) + interest(4) + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct dset *dset") + prompt("DSET address") + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + interest(4) + special(SPC_NOMOD) + } + field(LSET, DBF_NOACCESS) { + extra("struct lockRecord *lset") + prompt("Lock Set") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + interest(1) + menu(menuPriority) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Scheduling Priority") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + extra("char bkpt") + prompt("Break Point") + } + field(UDF, DBF_UCHAR) { + pp(TRUE) + initial("1") + prompt("Undefined") + promptgroup("10 - Common") + interest(1) + } + field(UDFS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + } + field(TIME, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(2) + prompt("Time") + extra("epicsTimeStamp time") + } + field(FLNK, DBF_FWDLINK) { + promptgroup("20 - Scan") + prompt("Forward Process Link") + interest(1) + } + field(VAL, DBF_DOUBLE) { + asl(ASL0) + prompt("Current EGU Value") + pp(TRUE) + promptgroup("40 - Input") + } + field(INP, DBF_INLINK) { + prompt("Input Specification") + promptgroup("40 - Input") + interest(1) + } + field(PREC, DBF_SHORT) { + interest(1) + prompt("Display Precision") + prop(YES) + promptgroup("80 - Display") + } + field(LINR, DBF_MENU) { + interest(1) + prompt("Linearization") + pp(TRUE) + special(SPC_LINCONV) + menu(menuConvert) + promptgroup("60 - Convert") + } + field(EGUF, DBF_DOUBLE) { + promptgroup("60 - Convert") + prompt("Engineer Units Full") + pp(TRUE) + interest(1) + special(SPC_LINCONV) + } + field(EGUL, DBF_DOUBLE) { + prompt("Engineer Units Low") + pp(TRUE) + promptgroup("60 - Convert") + special(SPC_LINCONV) + interest(1) + } + field(EGU, DBF_STRING) { + prop(YES) + promptgroup("80 - Display") + prompt("Engineering Units") + interest(1) + size(16) + } + field(HOPR, DBF_DOUBLE) { + interest(1) + prompt("High Operating Range") + promptgroup("80 - Display") + prop(YES) + } + field(LOPR, DBF_DOUBLE) { + prompt("Low Operating Range") + promptgroup("80 - Display") + prop(YES) + interest(1) + } + field(AOFF, DBF_DOUBLE) { + promptgroup("60 - Convert") + prompt("Adjustment Offset") + pp(TRUE) + interest(1) + } + field(ASLO, DBF_DOUBLE) { + interest(1) + prompt("Adjustment Slope") + initial("1") + pp(TRUE) + promptgroup("60 - Convert") + } + field(SMOO, DBF_DOUBLE) { + prompt("Smoothing") + promptgroup("60 - Convert") + interest(1) + } + field(HIHI, DBF_DOUBLE) { + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Hihi Alarm Limit") + interest(1) + } + field(LOLO, DBF_DOUBLE) { + interest(1) + prop(YES) + promptgroup("70 - Alarm") + prompt("Lolo Alarm Limit") + pp(TRUE) + } + field(HIGH, DBF_DOUBLE) { + prop(YES) + promptgroup("70 - Alarm") + prompt("High Alarm Limit") + pp(TRUE) + interest(1) + } + field(LOW, DBF_DOUBLE) { + prompt("Low Alarm Limit") + pp(TRUE) + prop(YES) + promptgroup("70 - Alarm") + interest(1) + } + field(HHSV, DBF_MENU) { + prop(YES) + promptgroup("70 - Alarm") + prompt("Hihi Severity") + pp(TRUE) + interest(1) + menu(menuAlarmSevr) + } + field(LLSV, DBF_MENU) { + promptgroup("70 - Alarm") + prop(YES) + pp(TRUE) + prompt("Lolo Severity") + interest(1) + menu(menuAlarmSevr) + } + field(HSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("High Severity") + promptgroup("70 - Alarm") + prop(YES) + } + field(LSV, DBF_MENU) { + pp(TRUE) + prompt("Low Severity") + promptgroup("70 - Alarm") + prop(YES) + menu(menuAlarmSevr) + interest(1) + } + field(HYST, DBF_DOUBLE) { + interest(1) + promptgroup("70 - Alarm") + prompt("Alarm Deadband") + } + field(AFTC, DBF_DOUBLE) { + promptgroup("70 - Alarm") + prompt("Alarm Filter Time Constant") + interest(1) + } + field(ADEL, DBF_DOUBLE) { + interest(1) + prompt("Archive Deadband") + promptgroup("80 - Display") + } + field(MDEL, DBF_DOUBLE) { + prompt("Monitor Deadband") + promptgroup("80 - Display") + interest(1) + } + field(LALM, DBF_DOUBLE) { + prompt("Last Value Alarmed") + interest(3) + special(SPC_NOMOD) + } + field(AFVL, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Alarm Filter Value") + } + field(ALST, DBF_DOUBLE) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Archived") + } + field(MLST, DBF_DOUBLE) { + prompt("Last Val Monitored") + interest(3) + special(SPC_NOMOD) + } + field(ESLO, DBF_DOUBLE) { + initial("1") + pp(TRUE) + prompt("Raw to EGU Slope") + promptgroup("60 - Convert") + interest(2) + } + field(EOFF, DBF_DOUBLE) { + interest(2) + promptgroup("60 - Convert") + prompt("Raw to EGU Offset") + pp(TRUE) + } + field(ROFF, DBF_ULONG) { + interest(2) + pp(TRUE) + prompt("Raw Offset") + } + field(PBRK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Ptrto brkTable") + extra("void * pbrk") + } + field(INIT, DBF_SHORT) { + special(SPC_NOMOD) + interest(3) + prompt("Initialized?") + } + field(LBRK, DBF_SHORT) { + interest(3) + special(SPC_NOMOD) + prompt("LastBreak Point") + } + field(RVAL, DBF_LONG) { + pp(TRUE) + prompt("Current Raw Value") + } + field(ORAW, DBF_LONG) { + prompt("Previous Raw Value") + interest(3) + special(SPC_NOMOD) + } + field(SIOL, DBF_INLINK) { + prompt("Simulation Input Link") + promptgroup("90 - Simulate") + interest(1) + } + field(SVAL, DBF_DOUBLE) { + prompt("Simulation Value") + } + field(SIML, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + interest(1) + } + field(SIMM, DBF_MENU) { + special(SPC_MOD) + menu(menuSimm) + interest(1) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + menu(menuAlarmSevr) + interest(2) + prompt("Simulation Mode Severity") + promptgroup("90 - Simulate") + } + field(OLDSIMM, DBF_MENU) { + special(SPC_NOMOD) + menu(menuSimm) + interest(4) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + promptgroup("90 - Simulate") + prompt("Sim. Mode Scan") + initial("65535") + interest(1) + menu(menuScan) + } + field(SDLY, DBF_DOUBLE) { + promptgroup("90 - Simulate") + prompt("Sim. Mode Async Delay") + initial("-1.0") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + } +} +device(ai, CONSTANT, devAiSoft, "Soft Channel") +device(ai, CONSTANT, devAiSoftRaw, "Raw Soft Channel") +device(ai, CONSTANT, devAiSoftCallback, "Async Soft Channel") +device(ai, INST_IO, devTimestampAI, "Soft Timestamp") +device(ai, INST_IO, devAiGeneralTime, "General Time") +device(ai, INST_IO, asynAiInt32, "asynInt32") +device(ai, INST_IO, asynAiInt32Average, "asynInt32Average") +device(ai, INST_IO, asynAiFloat64, "asynFloat64") +device(ai, INST_IO, asynAiFloat64Average, "asynFloat64Average") +recordtype(bo) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + special(SPC_NOMOD) + size(61) + prompt("Record Name") + } + field(DESC, DBF_STRING) { + prompt("Descriptor") + promptgroup("10 - Common") + size(41) + } + field(ASG, DBF_STRING) { + size(29) + special(SPC_AS) + prompt("Access Security Group") + promptgroup("10 - Common") + } + field(SCAN, DBF_MENU) { + special(SPC_SCAN) + menu(menuScan) + interest(1) + prompt("Scan Mechanism") + promptgroup("20 - Scan") + } + field(PINI, DBF_MENU) { + menu(menuPini) + interest(1) + prompt("Process at iocInit") + promptgroup("20 - Scan") + } + field(PHAS, DBF_SHORT) { + prompt("Scan Phase") + promptgroup("20 - Scan") + special(SPC_SCAN) + interest(1) + } + field(EVNT, DBF_STRING) { + prompt("Event Name") + promptgroup("20 - Scan") + size(40) + special(SPC_SCAN) + interest(1) + } + field(TSE, DBF_SHORT) { + interest(1) + prompt("Time Stamp Event") + promptgroup("20 - Scan") + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + interest(1) + prompt("Device Type") + promptgroup("10 - Common") + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Scanning Disable") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Monitor List") + extra("ELLLIST mlis") + } + field(BKLNK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + pp(TRUE) + prompt("Force Processing") + interest(3) + } + field(STAT, DBF_MENU) { + prompt("Alarm Status") + initial("UDF") + menu(menuAlarmStat) + special(SPC_NOMOD) + } + field(SEVR, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmStat) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + } + field(ACKT, DBF_MENU) { + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + menu(menuYesNo) + special(SPC_NOMOD) + interest(2) + } + field(DISS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + interest(2) + special(SPC_NOMOD) + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + special(SPC_NOMOD) + interest(1) + } + field(ASP, DBF_NOACCESS) { + prompt("Access Security Pvt") + extra("struct asgMember *asp") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("pprocessNotify") + extra("struct processNotify *ppn") + } + field(PPNR, DBF_NOACCESS) { + extra("struct processNotifyRecord *ppnr") + prompt("pprocessNotifyRecord") + interest(4) + special(SPC_NOMOD) + } + field(SPVT, DBF_NOACCESS) { + prompt("Scan Private") + extra("struct scan_element *spvt") + interest(4) + special(SPC_NOMOD) + } + field(RSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct typed_rset *rset") + prompt("Address of RSET") + } + field(DSET, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("DSET address") + extra("struct dset *dset") + } + field(DPVT, DBF_NOACCESS) { + extra("void *dpvt") + prompt("Device Private") + special(SPC_NOMOD) + interest(4) + } + field(RDES, DBF_NOACCESS) { + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + special(SPC_NOMOD) + interest(4) + } + field(LSET, DBF_NOACCESS) { + extra("struct lockRecord *lset") + prompt("Lock Set") + interest(4) + special(SPC_NOMOD) + } + field(PRIO, DBF_MENU) { + prompt("Scheduling Priority") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuPriority) + interest(1) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + prompt("Break Point") + extra("char bkpt") + } + field(UDF, DBF_UCHAR) { + interest(1) + prompt("Undefined") + initial("1") + pp(TRUE) + promptgroup("10 - Common") + } + field(UDFS, DBF_MENU) { + promptgroup("70 - Alarm") + initial("INVALID") + prompt("Undefined Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(TIME, DBF_NOACCESS) { + extra("epicsTimeStamp time") + prompt("Time") + interest(2) + special(SPC_NOMOD) + } + field(FLNK, DBF_FWDLINK) { + interest(1) + promptgroup("20 - Scan") + prompt("Forward Process Link") + } + field(VAL, DBF_ENUM) { + promptgroup("50 - Output") + pp(TRUE) + prompt("Current Value") + asl(ASL0) + } + field(OMSL, DBF_MENU) { + prompt("Output Mode Select") + promptgroup("50 - Output") + menu(menuOmsl) + interest(1) + } + field(DOL, DBF_INLINK) { + prompt("Desired Output Loc") + promptgroup("40 - Input") + interest(1) + } + field(OUT, DBF_OUTLINK) { + interest(1) + promptgroup("50 - Output") + prompt("Output Specification") + } + field(HIGH, DBF_DOUBLE) { + interest(1) + prompt("Seconds to Hold High") + promptgroup("30 - Action") + } + field(ZNAM, DBF_STRING) { + pp(TRUE) + prompt("Zero Name") + promptgroup("80 - Display") + prop(YES) + size(26) + interest(1) + } + field(ONAM, DBF_STRING) { + size(26) + interest(1) + pp(TRUE) + prompt("One Name") + promptgroup("80 - Display") + prop(YES) + } + field(RVAL, DBF_ULONG) { + pp(TRUE) + prompt("Raw Value") + } + field(ORAW, DBF_ULONG) { + prompt("prev Raw Value") + interest(3) + special(SPC_NOMOD) + } + field(MASK, DBF_ULONG) { + prompt("Hardware Mask") + special(SPC_NOMOD) + interest(1) + } + field(RPVT, DBF_NOACCESS) { + extra("void * rpvt") + prompt("Record Private") + special(SPC_NOMOD) + interest(4) + } + field(WDPT, DBF_NOACCESS) { + extra("void * wdpt") + prompt("Watch Dog Timer ID") + interest(4) + special(SPC_NOMOD) + } + field(ZSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Zero Error Severity") + pp(TRUE) + promptgroup("70 - Alarm") + } + field(OSV, DBF_MENU) { + promptgroup("70 - Alarm") + pp(TRUE) + prompt("One Error Severity") + interest(1) + menu(menuAlarmSevr) + } + field(COSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Change of State Sevr") + pp(TRUE) + promptgroup("70 - Alarm") + } + field(RBV, DBF_ULONG) { + prompt("Readback Value") + special(SPC_NOMOD) + } + field(ORBV, DBF_ULONG) { + prompt("Prev Readback Value") + interest(3) + special(SPC_NOMOD) + } + field(MLST, DBF_USHORT) { + prompt("Last Value Monitored") + special(SPC_NOMOD) + interest(3) + } + field(LALM, DBF_USHORT) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Alarmed") + } + field(SIOL, DBF_OUTLINK) { + promptgroup("90 - Simulate") + prompt("Simulation Output Link") + interest(1) + } + field(SIML, DBF_INLINK) { + interest(1) + promptgroup("90 - Simulate") + prompt("Simulation Mode Link") + } + field(SIMM, DBF_MENU) { + interest(1) + menu(menuYesNo) + special(SPC_MOD) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + promptgroup("90 - Simulate") + prompt("Simulation Mode Severity") + } + field(OLDSIMM, DBF_MENU) { + menu(menuSimm) + special(SPC_NOMOD) + interest(4) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + interest(1) + menu(menuScan) + promptgroup("90 - Simulate") + initial("65535") + prompt("Sim. Mode Scan") + } + field(SDLY, DBF_DOUBLE) { + interest(2) + promptgroup("90 - Simulate") + initial("-1.0") + prompt("Sim. Mode Async Delay") + } + field(SIMPVT, DBF_NOACCESS) { + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + interest(4) + special(SPC_NOMOD) + } + field(IVOA, DBF_MENU) { + promptgroup("50 - Output") + prompt("INVALID outpt action") + interest(2) + menu(menuIvoa) + } + field(IVOV, DBF_USHORT) { + interest(2) + promptgroup("50 - Output") + prompt("INVALID output value") + } +} +device(bo, CONSTANT, devBoSoft, "Soft Channel") +device(bo, CONSTANT, devBoSoftRaw, "Raw Soft Channel") +device(bo, CONSTANT, devBoSoftCallback, "Async Soft Channel") +device(bo, INST_IO, devBoGeneralTime, "General Time") +device(bo, INST_IO, devBoDbState, "Db State") +device(bo, INST_IO, asynBoInt32, "asynInt32") +device(bo, INST_IO, asynBoUInt32Digital, "asynUInt32Digital") +recordtype(longin) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + size(61) + special(SPC_NOMOD) + } + field(DESC, DBF_STRING) { + size(41) + prompt("Descriptor") + promptgroup("10 - Common") + } + field(ASG, DBF_STRING) { + prompt("Access Security Group") + promptgroup("10 - Common") + special(SPC_AS) + size(29) + } + field(SCAN, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Scan Mechanism") + interest(1) + menu(menuScan) + special(SPC_SCAN) + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + interest(1) + size(40) + special(SPC_SCAN) + promptgroup("20 - Scan") + prompt("Event Name") + } + field(TSE, DBF_SHORT) { + prompt("Time Stamp Event") + promptgroup("20 - Scan") + interest(1) + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + prompt("Device Type") + promptgroup("10 - Common") + interest(1) + } + field(DISV, DBF_SHORT) { + prompt("Disable Value") + initial("1") + promptgroup("20 - Scan") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + extra("ELLLIST mlis") + prompt("Monitor List") + interest(4) + special(SPC_NOMOD) + } + field(BKLNK, DBF_NOACCESS) { + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + special(SPC_NOMOD) + interest(4) + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmStat) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + menu(menuAlarmStat) + special(SPC_NOMOD) + interest(2) + } + field(NSEV, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + prompt("Alarm Ack Severity") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(ACKT, DBF_MENU) { + menu(menuYesNo) + special(SPC_NOMOD) + interest(2) + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + } + field(DISS, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + special(SPC_NOMOD) + interest(2) + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + interest(1) + special(SPC_NOMOD) + } + field(ASP, DBF_NOACCESS) { + extra("struct asgMember *asp") + prompt("Access Security Pvt") + interest(4) + special(SPC_NOMOD) + } + field(PPN, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + special(SPC_NOMOD) + interest(4) + } + field(SPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct scan_element *spvt") + prompt("Scan Private") + } + field(RSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct typed_rset *rset") + prompt("Address of RSET") + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + interest(4) + special(SPC_NOMOD) + } + field(DPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("void *dpvt") + prompt("Device Private") + } + field(RDES, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + } + field(LSET, DBF_NOACCESS) { + extra("struct lockRecord *lset") + prompt("Lock Set") + special(SPC_NOMOD) + interest(4) + } + field(PRIO, DBF_MENU) { + special(SPC_SCAN) + menu(menuPriority) + interest(1) + prompt("Scheduling Priority") + promptgroup("20 - Scan") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + prompt("Break Point") + extra("char bkpt") + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + prompt("Undefined") + initial("1") + pp(TRUE) + interest(1) + } + field(UDFS, DBF_MENU) { + initial("INVALID") + prompt("Undefined Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + interest(2) + special(SPC_NOMOD) + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_LONG) { + promptgroup("40 - Input") + pp(TRUE) + prompt("Current value") + asl(ASL0) + } + field(INP, DBF_INLINK) { + interest(1) + prompt("Input Specification") + promptgroup("40 - Input") + } + field(EGU, DBF_STRING) { + size(16) + interest(1) + prompt("Engineering Units") + prop(YES) + promptgroup("80 - Display") + } + field(HOPR, DBF_LONG) { + interest(1) + prop(YES) + promptgroup("80 - Display") + prompt("High Operating Range") + } + field(LOPR, DBF_LONG) { + interest(1) + prompt("Low Operating Range") + promptgroup("80 - Display") + prop(YES) + } + field(HIHI, DBF_LONG) { + interest(1) + pp(TRUE) + prompt("Hihi Alarm Limit") + promptgroup("70 - Alarm") + prop(YES) + } + field(LOLO, DBF_LONG) { + prop(YES) + promptgroup("70 - Alarm") + prompt("Lolo Alarm Limit") + pp(TRUE) + interest(1) + } + field(HIGH, DBF_LONG) { + interest(1) + prop(YES) + promptgroup("70 - Alarm") + prompt("High Alarm Limit") + pp(TRUE) + } + field(LOW, DBF_LONG) { + prop(YES) + promptgroup("70 - Alarm") + prompt("Low Alarm Limit") + pp(TRUE) + interest(1) + } + field(HHSV, DBF_MENU) { + prompt("Hihi Severity") + pp(TRUE) + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LLSV, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + pp(TRUE) + prompt("Lolo Severity") + promptgroup("70 - Alarm") + } + field(HSV, DBF_MENU) { + prompt("High Severity") + pp(TRUE) + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LSV, DBF_MENU) { + interest(1) + menu(menuAlarmSevr) + promptgroup("70 - Alarm") + pp(TRUE) + prompt("Low Severity") + } + field(HYST, DBF_LONG) { + interest(1) + prompt("Alarm Deadband") + promptgroup("70 - Alarm") + } + field(AFTC, DBF_DOUBLE) { + prompt("Alarm Filter Time Constant") + promptgroup("70 - Alarm") + interest(1) + } + field(AFVL, DBF_DOUBLE) { + interest(3) + special(SPC_NOMOD) + prompt("Alarm Filter Value") + } + field(ADEL, DBF_LONG) { + interest(1) + prompt("Archive Deadband") + promptgroup("80 - Display") + } + field(MDEL, DBF_LONG) { + interest(1) + promptgroup("80 - Display") + prompt("Monitor Deadband") + } + field(LALM, DBF_LONG) { + special(SPC_NOMOD) + interest(3) + prompt("Last Value Alarmed") + } + field(ALST, DBF_LONG) { + prompt("Last Value Archived") + interest(3) + special(SPC_NOMOD) + } + field(MLST, DBF_LONG) { + prompt("Last Val Monitored") + special(SPC_NOMOD) + interest(3) + } + field(SIOL, DBF_INLINK) { + promptgroup("90 - Simulate") + prompt("Sim Input Specifctn") + interest(1) + } + field(SVAL, DBF_LONG) { + prompt("Simulation Value") + } + field(SIML, DBF_INLINK) { + interest(1) + prompt("Sim Mode Location") + promptgroup("90 - Simulate") + } + field(SIMM, DBF_MENU) { + menu(menuYesNo) + special(SPC_MOD) + interest(1) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + promptgroup("90 - Simulate") + prompt("Sim mode Alarm Svrty") + interest(2) + menu(menuAlarmSevr) + } + field(OLDSIMM, DBF_MENU) { + special(SPC_NOMOD) + menu(menuSimm) + interest(4) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + promptgroup("90 - Simulate") + initial("65535") + prompt("Sim. Mode Scan") + interest(1) + menu(menuScan) + } + field(SDLY, DBF_DOUBLE) { + initial("-1.0") + prompt("Sim. Mode Async Delay") + promptgroup("90 - Simulate") + interest(2) + } + field(SIMPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Sim. Mode Private") + extra("epicsCallback *simpvt") + } +} +device(longin, CONSTANT, devLiSoft, "Soft Channel") +device(longin, CONSTANT, devLiSoftCallback, "Async Soft Channel") +device(longin, INST_IO, devLiGeneralTime, "General Time") +device(longin, INST_IO, asynLiInt32, "asynInt32") +device(longin, INST_IO, asynLiUInt32Digital, "asynUInt32Digital") +recordtype(mbbiDirect) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + special(SPC_NOMOD) + size(61) + } + field(DESC, DBF_STRING) { + size(41) + prompt("Descriptor") + promptgroup("10 - Common") + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + size(29) + special(SPC_AS) + } + field(SCAN, DBF_MENU) { + menu(menuScan) + special(SPC_SCAN) + interest(1) + prompt("Scan Mechanism") + promptgroup("20 - Scan") + } + field(PINI, DBF_MENU) { + interest(1) + menu(menuPini) + promptgroup("20 - Scan") + prompt("Process at iocInit") + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + prompt("Event Name") + promptgroup("20 - Scan") + size(40) + special(SPC_SCAN) + interest(1) + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + promptgroup("10 - Common") + prompt("Device Type") + interest(1) + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Disable Value") + initial("1") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + prompt("Scanning Disable") + promptgroup("20 - Scan") + interest(1) + } + field(MLOK, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("epicsMutexId mlok") + prompt("Monitor lock") + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("ELLLIST mlis") + prompt("Monitor List") + } + field(BKLNK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Backwards link tracking") + extra("ELLLIST bklnk") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + prompt("Force Processing") + pp(TRUE) + interest(3) + } + field(STAT, DBF_MENU) { + menu(menuAlarmStat) + special(SPC_NOMOD) + initial("UDF") + prompt("Alarm Status") + } + field(SEVR, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("Alarm Severity") + } + field(NSTA, DBF_MENU) { + prompt("New Alarm Status") + interest(2) + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(NSEV, DBF_MENU) { + special(SPC_NOMOD) + menu(menuAlarmSevr) + interest(2) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + menu(menuAlarmSevr) + special(SPC_NOMOD) + interest(2) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + interest(2) + menu(menuYesNo) + special(SPC_NOMOD) + promptgroup("70 - Alarm") + prompt("Alarm Ack Transient") + initial("YES") + } + field(DISS, DBF_MENU) { + promptgroup("70 - Alarm") + prompt("Disable Alarm Sevrty") + interest(1) + menu(menuAlarmSevr) + } + field(LCNT, DBF_UCHAR) { + prompt("Lock Count") + special(SPC_NOMOD) + interest(2) + } + field(PACT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Record active") + } + field(PUTF, DBF_UCHAR) { + interest(1) + special(SPC_NOMOD) + prompt("dbPutField process") + } + field(RPRO, DBF_UCHAR) { + prompt("Reprocess ") + interest(1) + special(SPC_NOMOD) + } + field(ASP, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("struct processNotify *ppn") + prompt("pprocessNotify") + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + } + field(SPVT, DBF_NOACCESS) { + extra("struct scan_element *spvt") + prompt("Scan Private") + special(SPC_NOMOD) + interest(4) + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + special(SPC_NOMOD) + interest(4) + } + field(DSET, DBF_NOACCESS) { + extra("struct dset *dset") + prompt("DSET address") + interest(4) + special(SPC_NOMOD) + } + field(DPVT, DBF_NOACCESS) { + prompt("Device Private") + extra("void *dpvt") + interest(4) + special(SPC_NOMOD) + } + field(RDES, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + prompt("Address of dbRecordType") + extra("struct dbRecordType *rdes") + } + field(LSET, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Lock Set") + extra("struct lockRecord *lset") + } + field(PRIO, DBF_MENU) { + prompt("Scheduling Priority") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuPriority) + interest(1) + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(1) + prompt("Break Point") + extra("char bkpt") + } + field(UDF, DBF_UCHAR) { + interest(1) + prompt("Undefined") + pp(TRUE) + initial("1") + promptgroup("10 - Common") + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Undefined Alarm Sevrty") + initial("INVALID") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + special(SPC_NOMOD) + interest(2) + } + field(FLNK, DBF_FWDLINK) { + interest(1) + prompt("Forward Process Link") + promptgroup("20 - Scan") + } + field(VAL, DBF_LONG) { + asl(ASL0) + promptgroup("40 - Input") + pp(TRUE) + prompt("Current Value") + } + field(NOBT, DBF_SHORT) { + promptgroup("40 - Input") + prompt("Number of Bits") + interest(1) + special(SPC_NOMOD) + } + field(INP, DBF_INLINK) { + prompt("Input Specification") + promptgroup("40 - Input") + interest(1) + } + field(RVAL, DBF_ULONG) { + prompt("Raw Value") + pp(TRUE) + } + field(ORAW, DBF_ULONG) { + prompt("Prev Raw Value") + special(SPC_NOMOD) + interest(3) + } + field(MASK, DBF_ULONG) { + prompt("Hardware Mask") + special(SPC_NOMOD) + interest(1) + } + field(MLST, DBF_LONG) { + interest(3) + special(SPC_NOMOD) + prompt("Last Value Monitored") + } + field(SHFT, DBF_USHORT) { + interest(1) + promptgroup("40 - Input") + prompt("Shift") + } + field(SIOL, DBF_INLINK) { + interest(1) + promptgroup("90 - Simulate") + prompt("Simulation Input Link") + } + field(SVAL, DBF_LONG) { + prompt("Simulation Value") + } + field(SIML, DBF_INLINK) { + interest(1) + prompt("Simulation Mode Link") + promptgroup("90 - Simulate") + } + field(SIMM, DBF_MENU) { + prompt("Simulation Mode") + menu(menuSimm) + special(SPC_MOD) + interest(1) + } + field(SIMS, DBF_MENU) { + menu(menuAlarmSevr) + interest(2) + prompt("Simulation Mode Severity") + promptgroup("90 - Simulate") + } + field(OLDSIMM, DBF_MENU) { + prompt("Prev. Simulation Mode") + interest(4) + menu(menuSimm) + special(SPC_NOMOD) + } + field(SSCN, DBF_MENU) { + prompt("Sim. Mode Scan") + initial("65535") + promptgroup("90 - Simulate") + menu(menuScan) + interest(1) + } + field(SDLY, DBF_DOUBLE) { + interest(2) + initial("-1.0") + prompt("Sim. Mode Async Delay") + promptgroup("90 - Simulate") + } + field(SIMPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + } + field(B0, DBF_UCHAR) { + interest(1) + prompt("Bit 0") + pp(TRUE) + } + field(B1, DBF_UCHAR) { + interest(1) + prompt("Bit 1") + pp(TRUE) + } + field(B2, DBF_UCHAR) { + interest(1) + pp(TRUE) + prompt("Bit 2") + } + field(B3, DBF_UCHAR) { + prompt("Bit 3") + pp(TRUE) + interest(1) + } + field(B4, DBF_UCHAR) { + interest(1) + pp(TRUE) + prompt("Bit 4") + } + field(B5, DBF_UCHAR) { + interest(1) + prompt("Bit 5") + pp(TRUE) + } + field(B6, DBF_UCHAR) { + prompt("Bit 6") + pp(TRUE) + interest(1) + } + field(B7, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 7") + interest(1) + } + field(B8, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 8") + interest(1) + } + field(B9, DBF_UCHAR) { + prompt("Bit 9") + pp(TRUE) + interest(1) + } + field(BA, DBF_UCHAR) { + prompt("Bit 10") + pp(TRUE) + interest(1) + } + field(BB, DBF_UCHAR) { + interest(1) + prompt("Bit 11") + pp(TRUE) + } + field(BC, DBF_UCHAR) { + interest(1) + pp(TRUE) + prompt("Bit 12") + } + field(BD, DBF_UCHAR) { + interest(1) + prompt("Bit 13") + pp(TRUE) + } + field(BE, DBF_UCHAR) { + prompt("Bit 14") + pp(TRUE) + interest(1) + } + field(BF, DBF_UCHAR) { + interest(1) + pp(TRUE) + prompt("Bit 15") + } + field(B10, DBF_UCHAR) { + prompt("Bit 16") + pp(TRUE) + interest(1) + } + field(B11, DBF_UCHAR) { + interest(1) + pp(TRUE) + prompt("Bit 17") + } + field(B12, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 18") + interest(1) + } + field(B13, DBF_UCHAR) { + interest(1) + pp(TRUE) + prompt("Bit 19") + } + field(B14, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 20") + interest(1) + } + field(B15, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 21") + interest(1) + } + field(B16, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 22") + interest(1) + } + field(B17, DBF_UCHAR) { + interest(1) + prompt("Bit 23") + pp(TRUE) + } + field(B18, DBF_UCHAR) { + interest(1) + prompt("Bit 24") + pp(TRUE) + } + field(B19, DBF_UCHAR) { + interest(1) + prompt("Bit 25") + pp(TRUE) + } + field(B1A, DBF_UCHAR) { + prompt("Bit 26") + pp(TRUE) + interest(1) + } + field(B1B, DBF_UCHAR) { + prompt("Bit 27") + pp(TRUE) + interest(1) + } + field(B1C, DBF_UCHAR) { + pp(TRUE) + prompt("Bit 28") + interest(1) + } + field(B1D, DBF_UCHAR) { + interest(1) + prompt("Bit 29") + pp(TRUE) + } + field(B1E, DBF_UCHAR) { + interest(1) + prompt("Bit 30") + pp(TRUE) + } + field(B1F, DBF_UCHAR) { + prompt("Bit 31") + pp(TRUE) + interest(1) + } +} +device(mbbiDirect, CONSTANT, devMbbiDirectSoft, "Soft Channel") +device(mbbiDirect, CONSTANT, devMbbiDirectSoftRaw, "Raw Soft Channel") +device(mbbiDirect, CONSTANT, devMbbiDirectSoftCallback, "Async Soft Channel") +device(mbbiDirect, INST_IO, asynMbbiDirectUInt32Digital, "asynUInt32Digital") +recordtype(lsi) { + %#include "epicsTypes.h" + %#include "link.h" + %#include "epicsMutex.h" + %#include "ellLib.h" + %#include "epicsTime.h" + %#include "devSup.h" + % + %/* Declare Device Support Entry Table */ + %typedef struct lsidset { + % long number; + % DEVSUPFUN report; + % DEVSUPFUN init; + % DEVSUPFUN init_record; + % DEVSUPFUN get_ioint_info; + % DEVSUPFUN read_string; + %} lsidset; + % + %#include "callback.h" + field(NAME, DBF_STRING) { + prompt("Record Name") + special(SPC_NOMOD) + size(61) + } + field(DESC, DBF_STRING) { + prompt("Descriptor") + promptgroup("10 - Common") + size(41) + } + field(ASG, DBF_STRING) { + promptgroup("10 - Common") + prompt("Access Security Group") + special(SPC_AS) + size(29) + } + field(SCAN, DBF_MENU) { + prompt("Scan Mechanism") + promptgroup("20 - Scan") + special(SPC_SCAN) + menu(menuScan) + interest(1) + } + field(PINI, DBF_MENU) { + promptgroup("20 - Scan") + prompt("Process at iocInit") + interest(1) + menu(menuPini) + } + field(PHAS, DBF_SHORT) { + promptgroup("20 - Scan") + prompt("Scan Phase") + interest(1) + special(SPC_SCAN) + } + field(EVNT, DBF_STRING) { + promptgroup("20 - Scan") + prompt("Event Name") + interest(1) + size(40) + special(SPC_SCAN) + } + field(TSE, DBF_SHORT) { + interest(1) + promptgroup("20 - Scan") + prompt("Time Stamp Event") + } + field(TSEL, DBF_INLINK) { + promptgroup("20 - Scan") + prompt("Time Stamp Link") + interest(1) + } + field(DTYP, DBF_DEVICE) { + prompt("Device Type") + promptgroup("10 - Common") + interest(1) + } + field(DISV, DBF_SHORT) { + promptgroup("20 - Scan") + initial("1") + prompt("Disable Value") + } + field(DISA, DBF_SHORT) { + prompt("Disable") + } + field(SDIS, DBF_INLINK) { + interest(1) + prompt("Scanning Disable") + promptgroup("20 - Scan") + } + field(MLOK, DBF_NOACCESS) { + extra("epicsMutexId mlok") + prompt("Monitor lock") + special(SPC_NOMOD) + interest(4) + } + field(MLIS, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Monitor List") + extra("ELLLIST mlis") + } + field(BKLNK, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("ELLLIST bklnk") + prompt("Backwards link tracking") + } + field(DISP, DBF_UCHAR) { + prompt("Disable putField") + } + field(PROC, DBF_UCHAR) { + pp(TRUE) + prompt("Force Processing") + interest(3) + } + field(STAT, DBF_MENU) { + prompt("Alarm Status") + initial("UDF") + special(SPC_NOMOD) + menu(menuAlarmStat) + } + field(SEVR, DBF_MENU) { + prompt("Alarm Severity") + special(SPC_NOMOD) + menu(menuAlarmSevr) + } + field(NSTA, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmStat) + prompt("New Alarm Status") + } + field(NSEV, DBF_MENU) { + interest(2) + menu(menuAlarmSevr) + special(SPC_NOMOD) + prompt("New Alarm Severity") + } + field(ACKS, DBF_MENU) { + interest(2) + special(SPC_NOMOD) + menu(menuAlarmSevr) + prompt("Alarm Ack Severity") + } + field(ACKT, DBF_MENU) { + initial("YES") + prompt("Alarm Ack Transient") + promptgroup("70 - Alarm") + special(SPC_NOMOD) + menu(menuYesNo) + interest(2) + } + field(DISS, DBF_MENU) { + prompt("Disable Alarm Sevrty") + promptgroup("70 - Alarm") + menu(menuAlarmSevr) + interest(1) + } + field(LCNT, DBF_UCHAR) { + special(SPC_NOMOD) + interest(2) + prompt("Lock Count") + } + field(PACT, DBF_UCHAR) { + prompt("Record active") + special(SPC_NOMOD) + interest(1) + } + field(PUTF, DBF_UCHAR) { + prompt("dbPutField process") + special(SPC_NOMOD) + interest(1) + } + field(RPRO, DBF_UCHAR) { + special(SPC_NOMOD) + interest(1) + prompt("Reprocess ") + } + field(ASP, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct asgMember *asp") + prompt("Access Security Pvt") + } + field(PPN, DBF_NOACCESS) { + prompt("pprocessNotify") + extra("struct processNotify *ppn") + interest(4) + special(SPC_NOMOD) + } + field(PPNR, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("pprocessNotifyRecord") + extra("struct processNotifyRecord *ppnr") + } + field(SPVT, DBF_NOACCESS) { + prompt("Scan Private") + extra("struct scan_element *spvt") + interest(4) + special(SPC_NOMOD) + } + field(RSET, DBF_NOACCESS) { + extra("struct typed_rset *rset") + prompt("Address of RSET") + interest(4) + special(SPC_NOMOD) + } + field(DSET, DBF_NOACCESS) { + prompt("DSET address") + extra("struct dset *dset") + special(SPC_NOMOD) + interest(4) + } + field(DPVT, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + prompt("Device Private") + extra("void *dpvt") + } + field(RDES, DBF_NOACCESS) { + interest(4) + special(SPC_NOMOD) + extra("struct dbRecordType *rdes") + prompt("Address of dbRecordType") + } + field(LSET, DBF_NOACCESS) { + prompt("Lock Set") + extra("struct lockRecord *lset") + special(SPC_NOMOD) + interest(4) + } + field(PRIO, DBF_MENU) { + menu(menuPriority) + special(SPC_SCAN) + interest(1) + prompt("Scheduling Priority") + promptgroup("20 - Scan") + } + field(TPRO, DBF_UCHAR) { + prompt("Trace Processing") + } + field(BKPT, DBF_NOACCESS) { + interest(1) + special(SPC_NOMOD) + prompt("Break Point") + extra("char bkpt") + } + field(UDF, DBF_UCHAR) { + promptgroup("10 - Common") + pp(TRUE) + initial("1") + prompt("Undefined") + interest(1) + } + field(UDFS, DBF_MENU) { + menu(menuAlarmSevr) + interest(1) + prompt("Undefined Alarm Sevrty") + initial("INVALID") + promptgroup("70 - Alarm") + } + field(TIME, DBF_NOACCESS) { + prompt("Time") + extra("epicsTimeStamp time") + special(SPC_NOMOD) + interest(2) + } + field(FLNK, DBF_FWDLINK) { + promptgroup("20 - Scan") + prompt("Forward Process Link") + interest(1) + } + field(VAL, DBF_NOACCESS) { + asl(ASL0) + special(SPC_DBADDR) + prompt("Current Value") + extra("char *val") + pp(TRUE) + } + field(OVAL, DBF_NOACCESS) { + special(SPC_DBADDR) + interest(3) + prompt("Old Value") + extra("char *oval") + } + field(SIZV, DBF_USHORT) { + interest(1) + special(SPC_NOMOD) + promptgroup("40 - Input") + prompt("Size of buffers") + initial("41") + } + field(LEN, DBF_ULONG) { + special(SPC_NOMOD) + prompt("Length of VAL") + } + field(OLEN, DBF_ULONG) { + prompt("Length of OVAL") + special(SPC_NOMOD) + } + field(INP, DBF_INLINK) { + prompt("Input Specification") + promptgroup("40 - Input") + interest(1) + } + field(MPST, DBF_MENU) { + menu(menuPost) + interest(1) + prompt("Post Value Monitors") + promptgroup("80 - Display") + } + field(APST, DBF_MENU) { + prompt("Post Archive Monitors") + promptgroup("80 - Display") + menu(menuPost) + interest(1) + } + field(SIML, DBF_INLINK) { + prompt("Simulation Mode Link") + promptgroup("90 - Simulate") + interest(1) + } + field(SIMM, DBF_MENU) { + interest(1) + special(SPC_MOD) + menu(menuYesNo) + prompt("Simulation Mode") + } + field(SIMS, DBF_MENU) { + promptgroup("90 - Simulate") + prompt("Simulation Mode Severity") + interest(2) + menu(menuAlarmSevr) + } + field(SIOL, DBF_INLINK) { + prompt("Simulation Input Link") + promptgroup("90 - Simulate") + interest(1) + } + field(OLDSIMM, DBF_MENU) { + menu(menuSimm) + special(SPC_NOMOD) + interest(4) + prompt("Prev. Simulation Mode") + } + field(SSCN, DBF_MENU) { + interest(1) + menu(menuScan) + promptgroup("90 - Simulate") + initial("65535") + prompt("Sim. Mode Scan") + } + field(SDLY, DBF_DOUBLE) { + interest(2) + promptgroup("90 - Simulate") + prompt("Sim. Mode Async Delay") + initial("-1.0") + } + field(SIMPVT, DBF_NOACCESS) { + special(SPC_NOMOD) + interest(4) + extra("epicsCallback *simpvt") + prompt("Sim. Mode Private") + } +} +device(lsi, CONSTANT, devLsiSoft, "Soft Channel") +device(lsi, INST_IO, devLsiEnviron, "getenv") +driver(drvAsyn) +link(calc, lnkCalcIf) +link(state, lnkStateIf) +link(trace, lnkTraceIf) +link(debug, lnkDebugIf) +link(const, lnkConstIf) +registrar(asynInterposeEchoRegister) +registrar(asynInterposeEosRegister) +registrar(asynInterposeDelayRegister) +registrar(motorRegister) +registrar(decInitialize) +registrar(asSub) +registrar(motorUtilRegister) +registrar(arrInitialize) +registrar(tsInitialize) +registrar(drvAsynSerialPortRegisterCommands) +registrar(syncInitialize) +registrar(drvAsynIPServerPortRegisterCommands) +registrar(asynInterposeFlushRegister) +registrar(SMC9300Register) +registrar(asynRegister) +registrar(drvAsynIPPortRegisterCommands) +registrar(asynMotorControllerRegister) +registrar(dbndInitialize) +registrar(rsrvRegistrar) +variable(logClientDebug, int) +variable(histogramSDELprecision, int) +variable(boHIGHlimit, double) +variable(lnkDebug_debug, int) +variable(seqDLYlimit, double) +variable(dbRecordsAbcSorted, int) +variable(dbBptNotMonotonic, int) +variable(dbJLinkDebug, int) +variable(dbConvertStrict, int) +variable(dbRecordsOnceOnly, int) +variable(dbTemplateMaxVars, int) +variable(calcoutODLYprecision, int) +variable(dbQuietMacroWarnings, int) +variable(dbThreadRealtimeLock, int) +variable(dbAccessDebugPUTF, int) +variable(calcoutODLYlimit, double) +variable(seqDLYprecision, int) +variable(callbackParallelThreadsDefault, int) +variable(CASDEBUG, int) +variable(asCaDebug, int) +variable(boHIGHprecision, int) +variable(atExitDebug, int) diff --git a/testpmacV3/db/motorMessage.db b/testpmacV3/db/motorMessage.db new file mode 100644 index 0000000..a8abc9e --- /dev/null +++ b/testpmacV3/db/motorMessage.db @@ -0,0 +1,9 @@ + +# The message text +record(waveform, "$(P)$(M)-MsgTxt") { + field(DTYP, "asynOctetRead") + field(INP, "@asyn($(PORT),$(N),1) MOTOR_MESSAGE_TEXT") + field(FTVL, "CHAR") + field(NELM, "80") + field(SCAN, "I/O Intr") +} diff --git a/testpmacV3/db/pmacV3.db b/testpmacV3/db/pmacV3.db new file mode 100644 index 0000000..37c5b4f --- /dev/null +++ b/testpmacV3/db/pmacV3.db @@ -0,0 +1,14 @@ +# enable axis +record(longout, "$(P)$(M):Enable") { + field(DTYP, "asynInt32") + field(OUT, "@asyn($(PORT),$(N),1) ENABLE_AXIS") + field(PINI, "YES") +} + +# enable axis +record(longin, "$(P)$(M):Enable_RBV") { + field(DTYP, "asynInt32") + field(INP, "@asyn($(PORT),$(N),1) AXIS_ENABLED") + field(PINI, "YES") + field(SCAN, "1 second") +} diff --git a/testpmacV3/mcu.substitutions b/testpmacV3/mcu.substitutions new file mode 100644 index 0000000..b57f8b4 --- /dev/null +++ b/testpmacV3/mcu.substitutions @@ -0,0 +1,27 @@ +file "$(TOP)/db/basic_asyn_motor.db" +{ +pattern +{P, N, M, DTYP, PORT, ADDR, DESC, EGU, DIR, VELO, VBAS, ACCL, BDST, BVEL, BACC, MRES, PREC, DHLM, DLLM, INIT} +{SQ:TEST:mcu:, 2, "m$(N)", "asynMotor", mcu, 2, "m$(N)", degrees, Pos, 2.0, 0.1, .2, 0, 1, .2, .001, 3, 358., 2., ""} +{SQ:TEST:mcu:, 6, "m$(N)", "asynMotor", mcu, 6, "m$(N)", degrees, Pos, 2.0, 0.1, .2, 0, 1, .2, .001, 3, 358., 2., ""} +{SQ:TEST:mcu:,10, "m$(N)", "asynMotor", mcu,10, "m$(N)", degrees, Pos, 2.0, 0.1, .2, 0, 1, .2, .001, 3, 358., 2., ""} +} + +file "$(TOP)/db/motorMessage.db" +{ +pattern +{P,N, M,PORT} +{SQ:TEST:mcu:, 2, "m$(N)", mcu} +{SQ:TEST:mcu:, 6, "m$(N)", mcu} +{SQ:TEST:mcu:,10, "m$(N)", mcu} +} + +file "$(TOP)/db/pmacV3.db" +{ +pattern +{P,N, M,PORT} +{SQ:TEST:mcu:, 2, "m$(N)", mcu} +{SQ:TEST:mcu:, 6, "m$(N)", mcu} +{SQ:TEST:mcu:,10, "m$(N)", mcu} +} + diff --git a/testpmacV3/st.cmd b/testpmacV3/st.cmd new file mode 100755 index 0000000..eef4bd2 --- /dev/null +++ b/testpmacV3/st.cmd @@ -0,0 +1,25 @@ +#!/ioc/tools/iocsh + +require sinq,brambilla_m +#require sinq,koennecke + +epicsEnvSet("TOP","/afs/psi.ch/project/sinqdev/sinqepicsapp/testpmacV3") + +epicsEnvSet("EPICS_CA_ADDR_LIST","127.0.0.1") + +epicsEnvSet("STREAM_PROTOCOL_PATH","$(TOP)/db") + + +var streamDebug 3 + +# motors + +pmacAsynIPConfigure("pmacV3", "129.129.138.234:1025") +pmacV3CreateController("mcu","pmacV3",0,16,50,1000); +pmacV3CreateAxis("mcu",2,0); +pmacV3CreateAxis("mcu",6,0); +pmacV3CreateAxis("mcu",10,0); +dbLoadTemplate "$(TOP)/mcu.substitutions" +dbLoadRecords("$(TOP)/db/asynRecord.db","P=SQ:TEST:,R=mcu,PORT=pmacV3,ADDR=0,OMAX=80,IMAX=80") + +iocInit diff --git a/utils/macmaster.py b/utils/macmaster.py new file mode 100644 index 0000000..0ebac3a --- /dev/null +++ b/utils/macmaster.py @@ -0,0 +1,53 @@ +""" + Usage: macmaster.py macmasterhost port + Listen for commands to send and returns reponse + until exit has been typed + + Mark Koennecke, March 2023 +""" + +import socket +import struct + + +class MasterMACS(): + def __init__(self, host, port): + self._socke = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + self._socke.connect((host, int(port))) + + def send(self, command): + buf = struct.pack('BBBB', 0x05, len(command) + 4, 0, 0x19) + buf += bytes(command, 'utf-8') + buf += struct.pack('BB', 0x0D, 0x03) + self._socke.send(buf) + + def receive(self): + buf = self._socke.recv(35, socket.MSG_WAITALL) + if len(buf) < 35: + raise EOFException('Master MACS returned only %d bytes, 30 expected' % len(buf)) + idx = buf.find(0x0D) + ackbyte = buf[idx-1] + if ackbyte == 0x06: + ack = 'ACK' + elif ackbyte == 0x15: + ack = 'NAK', + else: + ack = 'NO' + reply = buf[4:idx-1].decode('utf-8') + return ack, reply + +if __name__ == "__main__": + from sys import argv, exit, stdin + if len(argv) < 3: + print('Usage:\n\tmacmaster.py machost macport') + exit(1) + mac = MasterMACS(argv[1], argv[2]) + while(True): + # import pdb; pdb.set_trace() + line = stdin.readline() + if line.find('exit') >= 0: + exit(0) + mac.send(line.strip()) + ack, reply = mac.receive() + print('%s, %s' %(ack, reply)) + diff --git a/utils/syncMasterMAC.py b/utils/syncMasterMAC.py new file mode 100755 index 0000000..f15eb65 --- /dev/null +++ b/utils/syncMasterMAC.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python3 +""" +This little program synchronizes an EPICS substitutions file with values read +from a MasterMAC motor controller. + +Mark Koennecke, February 2023 +""" +import sys + +from macmaster import MasterMACS + +def find_commas(rawline): + comma_list = [] + for i in range(len(rawline)): + if rawline[i] == ',': + comma_list.append(i) + return comma_list + +def pretty_line(newlist, comma_list): + """ + adds spaces to match the tabbing of the patter line + """ + newline = '' + for item, idx in zip(newlist, comma_list): + length = len(newline) + 1 + len(item) + if length < idx: + newline += ' ' * (idx - length) + newline += item + newline += ',' + newline += newlist[-1] + return newline[0:-1] + +def transact(command): + global mac + mac.send(command) + return mac.receive() + +def fix_line(par_list, index_list): + # import pdb; pdb.set_trace() + addridx = index_list.index('ADDR') + motNo = int(par_list[addridx]) + ack, reply = transact('%dR24' % motNo) + idx = reply.find('=') + lowlim = reply[idx+1:] + lowidx = index_list.index('DLLM') + par_list[lowidx] = lowlim.strip() + ack, reply = transact('%dR23' % motNo) + idx = reply.find('=') + highlim = reply[idx+1:] + highidx = index_list.index('DHLM') + par_list[highidx] = highlim.strip() + # speed = transact('Q%d03' % motNo) + # speedidx = index_list['VELO'] + # par_list[speedidx] = speed.trim() + return par_list + +def scan_substitution_file(filename): + index_list = None + # import pdb; pdb.set_trace() + with open(filename, 'r') as fin: + rawline = fin.readline() + while rawline: + line = rawline.replace(' ','') + line = line.strip('{}') + l = line.split(',') + if line.find('DHLM') > 0: + index_list = l + comma_list = find_commas(rawline) + sys.stdout.write(rawline) + elif not index_list: + sys.stdout.write(rawline) + else: + if len(l) == len(index_list): + newlist = fix_line(l, index_list) + # newline = ','.join(newlist) + newline = pretty_line(newlist, comma_list) + sys.stdout.write('{' + newline + '\n') + else: + sys.stdout.write(rawline) + rawline = fin.readline() + +#------------------ main +if len(sys.argv) < 4: + print('Usage:\n\tsyncMMACSub.py \n') + sys.exit(1) + +mac = MasterMACS(sys.argv[1], sys.argv[2]) +scan_substitution_file(sys.argv[3]) + +