/* * ASYN UInt32Digital driver for MPS Buffer Readback */ #include #include #include #include #include #include #include #include #include "MachineRatesBuffer.h" #include "MachineStateBuffer.h" /* * Driver private storage */ typedef struct dpvtStruct { asynInterface asynCommon; asynInterface asynUInt32Digital; int (*readFunc)(unsigned int index); int (*writeFunc)(unsigned int index, char value); } dpvt; #if 0 #pragma mark - #pragma mark asynCommon methods #endif /* * asynCommon methods */ static void mpsBufferReport(void *pvt, FILE *fp, int details) { if (details >= 3) { fprintf(fp, "report\n"); } } static asynStatus mpsBufferConnect(void *pvt, asynUser *pasynUser) { pasynManager->exceptionConnect(pasynUser); return asynSuccess; } static asynStatus mpsBufferDisconnect(void *pvt, asynUser *pasynUser) { pasynManager->exceptionDisconnect(pasynUser); return asynSuccess; } static asynCommon asynCommonMethods = { mpsBufferReport, mpsBufferConnect, mpsBufferDisconnect }; #if 0 #pragma mark - #pragma mark asynUInt32Digital common methods #endif /* static asynStatus noRead(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "This record is write only."); return asynError; } */ static asynStatus noWrite(void *pvt, asynUser *pasynUser, epicsUInt32 value, epicsUInt32 mask) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "This record is read only."); return asynError; } #if 0 #pragma mark - #pragma mark asynUInt32Digital Rate Status Methods #endif static asynStatus readRates(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { /* dpvt *pdpvt = (dpvt *) pvt; */ asynStatus status; int index; int err; epicsUInt32 tmpval; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Read */ tmpval = 0; err = getRateAfterDevice(&tmpval, index); if (err != MPS_SUCCESS) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "readRates: address %d, error %d", index, err); return asynError; } *value = tmpval; return asynSuccess; } #if 0 #pragma mark - #pragma mark asynUInt32Digital Rate Request Methods #endif static asynStatus readRateRequest(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { /* dpvt *pdpvt = (dpvt *) pvt; */ asynStatus status; int index; int err; epicsUInt32 tmpval; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Read */ tmpval = 0; err = getRateAfterDevice(&tmpval, index); switch (index) { case 1: err = mpsGetRateRequest(MPSMitigationDeviceAll, MPSRateSingleShot, &tmpval); break; case 2: err = mpsGetRateRequest(MPSMitigationDeviceAll, MPSRateBurstMode, &tmpval); break; case 11: err = mpsGetRateRequest(MPSMitigationDevicePockelsCell, MPSRate60Hz, &tmpval); break; case 12: err = mpsGetRateRequest(MPSMitigationDevicePockelsCell, MPSRate30Hz, &tmpval); break; case 13: err = mpsGetRateRequest(MPSMitigationDevicePockelsCell, MPSRate10Hz, &tmpval); break; case 14: err = mpsGetRateRequest(MPSMitigationDevicePockelsCell, MPSRate1Hz, &tmpval); break; case 15: err = mpsGetRateRequest(MPSMitigationDevicePockelsCell, MPSRateBurstMode, &tmpval); break; case 16: err = mpsGetRateRequest(MPSMitigationDevicePockelsCell, MPSRateSingleShot, &tmpval); break; case 21: err = mpsGetRateRequest(MPSMitigationDeviceBykik, MPSRate60Hz, &tmpval); break; case 22: err = mpsGetRateRequest(MPSMitigationDeviceBykik, MPSRate30Hz, &tmpval); break; case 23: err = mpsGetRateRequest(MPSMitigationDeviceBykik, MPSRate10Hz, &tmpval); break; case 24: err = mpsGetRateRequest(MPSMitigationDeviceBykik, MPSRate1Hz, &tmpval); break; case 25: err = mpsGetRateRequest(MPSMitigationDeviceBykik, MPSRateBurstMode, &tmpval); break; case 26: err = mpsGetRateRequest(MPSMitigationDeviceBykik, MPSRateSingleShot, &tmpval); break; case 31: err = mpsGetRateRequest(MPSMitigationDeviceGunHxr, MPSRate60Hz, &tmpval); break; case 32: err = mpsGetRateRequest(MPSMitigationDeviceGunHxr, MPSRate30Hz, &tmpval); break; case 33: err = mpsGetRateRequest(MPSMitigationDeviceGunHxr, MPSRate10Hz, &tmpval); break; case 34: err = mpsGetRateRequest(MPSMitigationDeviceGunHxr, MPSRate1Hz, &tmpval); break; case 35: err = mpsGetRateRequest(MPSMitigationDeviceGunHxr, MPSRateBurstMode, &tmpval); break; case 36: err = mpsGetRateRequest(MPSMitigationDeviceGunHxr, MPSRateSingleShot, &tmpval); break; case 41: err = mpsGetRateRequest(MPSMitigationDeviceGunSxr, MPSRate60Hz, &tmpval); break; case 42: err = mpsGetRateRequest(MPSMitigationDeviceGunSxr, MPSRate30Hz, &tmpval); break; case 43: err = mpsGetRateRequest(MPSMitigationDeviceGunSxr, MPSRate10Hz, &tmpval); break; case 44: err = mpsGetRateRequest(MPSMitigationDeviceGunSxr, MPSRate1Hz, &tmpval); break; case 45: err = mpsGetRateRequest(MPSMitigationDeviceGunSxr, MPSRateBurstMode, &tmpval); break; case 46: err = mpsGetRateRequest(MPSMitigationDeviceGunSxr, MPSRateSingleShot, &tmpval); break; case 51: err = mpsGetRateRequest(MPSMitigationDeviceBykikS, MPSRate60Hz, &tmpval); break; case 52: err = mpsGetRateRequest(MPSMitigationDeviceBykikS, MPSRate30Hz, &tmpval); break; case 53: err = mpsGetRateRequest(MPSMitigationDeviceBykikS, MPSRate10Hz, &tmpval); break; case 54: err = mpsGetRateRequest(MPSMitigationDeviceBykikS, MPSRate1Hz, &tmpval); break; case 55: err = mpsGetRateRequest(MPSMitigationDeviceBykikS, MPSRateBurstMode, &tmpval); break; case 56: err = mpsGetRateRequest(MPSMitigationDeviceBykikS, MPSRateSingleShot, &tmpval); break; default: err = MPS_ERROR; break; } if (err != MPS_SUCCESS) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "readRateRequest: address %d, error %d", index, err); return asynError; } *value = tmpval; return asynSuccess; } static asynStatus writeRateRequest(void *pvt, asynUser *pasynUser, epicsUInt32 value, epicsUInt32 mask) { asynStatus status; unsigned int index; int err; /* Get index */ status = pasynManager->getAddr(pasynUser, (int *) &index); if (status != asynSuccess) { return status; } /* Write */ switch (index) { case 1: err = mpsSetRateRequest(MPSMitigationDeviceAll, MPSRateSingleShot, value); break; case 2: err = mpsSetRateRequest(MPSMitigationDeviceAll, MPSRateBurstMode, value); break; case 11: err = mpsSetRateRequest(MPSMitigationDevicePockelsCell, MPSRate60Hz, value); break; case 12: err = mpsSetRateRequest(MPSMitigationDevicePockelsCell, MPSRate30Hz, value); break; case 13: err = mpsSetRateRequest(MPSMitigationDevicePockelsCell, MPSRate10Hz, value); break; case 14: err = mpsSetRateRequest(MPSMitigationDevicePockelsCell, MPSRate1Hz, value); break; case 15: err = mpsSetRateRequest(MPSMitigationDevicePockelsCell, MPSRateBurstMode, value); break; case 16: err = mpsSetRateRequest(MPSMitigationDevicePockelsCell, MPSRateSingleShot, value); break; case 21: err = mpsSetRateRequest(MPSMitigationDeviceBykik, MPSRate60Hz, value); break; case 22: err = mpsSetRateRequest(MPSMitigationDeviceBykik, MPSRate30Hz, value); break; case 23: err = mpsSetRateRequest(MPSMitigationDeviceBykik, MPSRate10Hz, value); break; case 24: err = mpsSetRateRequest(MPSMitigationDeviceBykik, MPSRate1Hz, value); break; case 25: err = mpsSetRateRequest(MPSMitigationDeviceBykik, MPSRateBurstMode, value); break; case 26: err = mpsSetRateRequest(MPSMitigationDeviceBykik, MPSRateSingleShot, value); break; case 31: err = mpsSetRateRequest(MPSMitigationDeviceGunHxr, MPSRate60Hz, value); break; case 32: err = mpsSetRateRequest(MPSMitigationDeviceGunHxr, MPSRate30Hz, value); break; case 33: err = mpsSetRateRequest(MPSMitigationDeviceGunHxr, MPSRate10Hz, value); break; case 34: err = mpsSetRateRequest(MPSMitigationDeviceGunHxr, MPSRate1Hz, value); break; case 35: err = mpsSetRateRequest(MPSMitigationDeviceGunHxr, MPSRateBurstMode, value); break; case 36: err = mpsSetRateRequest(MPSMitigationDeviceGunHxr, MPSRateSingleShot, value); break; case 41: err = mpsSetRateRequest(MPSMitigationDeviceGunSxr, MPSRate60Hz, value); break; case 42: err = mpsSetRateRequest(MPSMitigationDeviceGunSxr, MPSRate30Hz, value); break; case 43: err = mpsSetRateRequest(MPSMitigationDeviceGunSxr, MPSRate10Hz, value); break; case 44: err = mpsSetRateRequest(MPSMitigationDeviceGunSxr, MPSRate1Hz, value); break; case 45: err = mpsSetRateRequest(MPSMitigationDeviceGunSxr, MPSRateBurstMode, value); break; case 46: err = mpsSetRateRequest(MPSMitigationDeviceGunSxr, MPSRateSingleShot, value); break; case 51: err = mpsSetRateRequest(MPSMitigationDeviceBykikS, MPSRate60Hz, value); break; case 52: err = mpsSetRateRequest(MPSMitigationDeviceBykikS, MPSRate30Hz, value); break; case 53: err = mpsSetRateRequest(MPSMitigationDeviceBykikS, MPSRate10Hz, value); break; case 54: err = mpsSetRateRequest(MPSMitigationDeviceBykikS, MPSRate1Hz, value); break; case 55: err = mpsSetRateRequest(MPSMitigationDeviceBykikS, MPSRateBurstMode, value); break; case 56: err = mpsSetRateRequest(MPSMitigationDeviceBykikS, MPSRateSingleShot, value); break; default: err = MPS_ERROR; break; } if (err != MPS_SUCCESS) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "writeRateRequest: address %u, error %d", index, err); return asynError; } return asynSuccess; } #if 0 #pragma mark - #pragma mark asynUInt32Digital Destination Methods #endif static asynStatus readDestination(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { *value = getBeamDestination(); return asynSuccess; } static asynStatus writeMode(void *pvt, asynUser *pasynUser, epicsUInt32 value, epicsUInt32 mask) { asynStatus status; int err; /* Write */ switch (value) { case 1: err = setOperatingMode(MPSModeHxr00Sxr00); break; case 2: err = setOperatingMode(MPSModeHxr00Sxr120); break; case 3: err = setOperatingMode(MPSModeHxr01Sxr119); break; case 4: err = setOperatingMode(MPSModeHxr10Sxr110); break; case 5: err = setOperatingMode(MPSModeHxr30Sxr90); break; case 6: err = setOperatingMode(MPSModeHxr60Sxr60); break; case 7: err = setOperatingMode(MPSModeHxr90Sxr30); break; case 8: err = setOperatingMode(MPSModeHxr110Sxr10); break; case 9: err = setOperatingMode(MPSModeHxr119Sxr01); break; case 10: err = setOperatingMode(MPSModeHxr120Sxr00); break; default: err = MPS_ERROR; break; } if (err != MPS_SUCCESS) { err = setOperatingMode(MPSModeInvalid); epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "Desired Operating Mode Out of Bounds!"); return asynError; } return asynSuccess; } static asynStatus readMode(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { *value = getOperatingMode(); return asynSuccess; } #if 0 #pragma mark - #pragma mark asynUInt32Digital Burst Mode Status Methods #endif static asynStatus readBurstModeStatus(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { /* dpvt *pdpvt = (dpvt *) pvt; */ asynStatus status; int index; int err; epicsUInt32 tmpval; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Read */ tmpval = 0; err = getBurstModeStatusForDevice(&tmpval, index); if (err != MPS_SUCCESS) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "readBurstModeStatus: address %d, error %d", index, err); return asynError; } switch (tmpval) { case MPSRateBurstModeNotActive: *value = 1; break; case MPSRateSingleShot: *value = 2; break; case MPSRateBurstMode: *value = 3; break; default: *value = 0; break; } return asynSuccess; } static asynStatus readCurrentRate(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { /* dpvt *pdpvt = (dpvt *) pvt; */ asynStatus status; int index; int err; epicsUInt32 tmpval; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Read */ tmpval = 0; *value = getCurrentRate(index); return asynSuccess; } static asynStatus readError(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { /* dpvt *pdpvt = (dpvt *) pvt; */ asynStatus status; int index; int err; epicsUInt32 tmpval; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Read */ tmpval = 0; *value = getErrorCount(index); return asynSuccess; } static asynStatus writeUser(void *pvt, asynUser *pasynUser, epicsUInt32 value, epicsUInt32 mask) { asynStatus status; unsigned int index; int err; /* Get index */ status = pasynManager->getAddr(pasynUser, (int *) &index); if (status != asynSuccess) { return status; } /* Write */ switch (index) { case 0: err = setBykikUser(value); break; case 1: err = setBykikSUser(value); break; default: err = MPS_ERROR; break; } if (err != MPS_SUCCESS) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "writeRateRequest: address %u, error %d", index, err); return asynError; } return asynSuccess; } static asynStatus readUser(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { /* dpvt *pdpvt = (dpvt *) pvt; */ asynStatus status; int index; int err; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Read */ switch (index) { case 0: *value = getBykikUser(); break; case 1: *value = getBykikSUser(); break; default: *value = 0; break; } return asynSuccess; } static asynStatus readBykik(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { *value = getBykik(); return asynSuccess; } #if 0 #pragma mark - #pragma mark asynUInt32Digital method structs #endif static asynStatus writeWire(void *pvt, asynUser *pasynUser, epicsUInt32 value, epicsUInt32 mask) { asynStatus status; unsigned int index; int err; /* Get index */ status = pasynManager->getAddr(pasynUser, (int *) &index); if (status != asynSuccess) { return status; } /* Write */ switch (index) { case 0: err = setHXRWireScan(value); break; case 1: err = setSXRWireScan(value); break; default: err = MPS_ERROR; break; } if (err != MPS_SUCCESS) { epicsSnprintf(pasynUser->errorMessage, pasynUser->errorMessageSize, "writeRateRequest: address %u, error %d", index, err); return asynError; } return asynSuccess; } static asynStatus readWire(void *pvt, asynUser *pasynUser, unsigned int *value, unsigned int mask) { /* dpvt *pdpvt = (dpvt *) pvt; */ asynStatus status; int index; int err; /* Get index */ if ((status = pasynManager->getAddr(pasynUser, &index)) != asynSuccess) { return status; } /* Read */ switch (index) { case 0: *value = getHXRWireScan(); break; case 1: *value = getSXRWireScan(); break; default: *value = 0; break; } return asynSuccess; } static asynUInt32Digital asynUInt32DigitalMethodsRateStatus = { noWrite, readRates }; static asynUInt32Digital asynUInt32DigitalMethodsDestination = { noWrite, readDestination }; static asynUInt32Digital asynUInt32DigitalMethodsBurstModeStatus = { noWrite, readBurstModeStatus }; static asynUInt32Digital asynUInt32DigitalMethodsRateRequest = { writeRateRequest, readRateRequest }; static asynUInt32Digital asynUInt32DigitalMethodsMode = { writeMode, readMode }; static asynUInt32Digital asynUInt32DigitalMethodsCurrentRate = { noWrite, readCurrentRate }; static asynUInt32Digital asynUInt32DigitalMethodsBykikOut = { noWrite, readBykik }; static asynUInt32Digital asynUInt32DigitalMethodsUserAbort = { writeUser, readUser }; static asynUInt32Digital asynUInt32DigitalMethodsErrorCounter = { noWrite, readError }; #if 0 #pragma mark - #pragma mark Configure Port Instances #endif /* * Configure and register the port instances */ void devMpsRatesBurstDestinationRegistrar() { dpvt *pdpvt; asynStatus status; const char *portNames[9] = {"devMpsRateStatus", /* 0 */ "devMpsDestination", /* 1 */ "devMpsBurstModeStatus", /* 2 */ "devMpsRateRequest", /* 3 */ "devMpsOperatingMode", /* 4 */ "devMPSCurrentRate", /* 5 */ "devMPSBykik", /* 6 */ "devMpsUserAbort", /* 7 */ "devMpsErrorCounter"}; /* 8 */ const char *portName; int i; for(i = 0; i < sizeof(portNames)/sizeof(portNames[0]); i++) { portName = portNames[i]; pdpvt = callocMustSucceed(sizeof(dpvt), 1, portName); /* * Register with ASYN * * registerPort(portName, attributes, autoConnect, priority (for worker thread), stack size (for worker thread)) * Note: I/O actions do not block read thread. Therefore, no worker thread is created. Priority and stack size should be zero. */ status = pasynManager->registerPort(portName, ASYN_MULTIDEVICE, 1, 0, 0); if(status!=asynSuccess) { errlogPrintf("devMpsRatesBurstDestinationRegistrar: registerPort failed\n"); return; } pdpvt->asynCommon.interfaceType = asynCommonType; pdpvt->asynCommon.pinterface = (void *)&asynCommonMethods; pdpvt->asynCommon.drvPvt = pdpvt; status = pasynManager->registerInterface(portName, &pdpvt->asynCommon); if (status!=asynSuccess) { errlogPrintf("devMpsRatesBurstDestinationRegistrar: registerInterface failed\n"); return; } pdpvt->asynUInt32Digital.interfaceType = asynUInt32DigitalType; switch(i) { case 0: pdpvt->asynUInt32Digital.pinterface = (void *) &(asynUInt32DigitalMethodsRateStatus); break; case 1: pdpvt->asynUInt32Digital.pinterface = (void *) &(asynUInt32DigitalMethodsDestination); break; case 2: pdpvt->asynUInt32Digital.pinterface = (void *) &(asynUInt32DigitalMethodsBurstModeStatus); break; case 3: pdpvt->asynUInt32Digital.pinterface = (void *) &(asynUInt32DigitalMethodsRateRequest); break; case 4: pdpvt->asynUInt32Digital.pinterface = (void *) &(asynUInt32DigitalMethodsMode); break; case 5: pdpvt->asynUInt32Digital.pinterface = (void *) &(asynUInt32DigitalMethodsCurrentRate); break; case 6: pdpvt->asynUInt32Digital.pinterface = (void *) &(asynUInt32DigitalMethodsBykikOut); break; case 7: pdpvt->asynUInt32Digital.pinterface = (void *) &(asynUInt32DigitalMethodsUserAbort); break; case 8: pdpvt->asynUInt32Digital.pinterface = (void *) &(asynUInt32DigitalMethodsErrorCounter); break; default: pdpvt->asynUInt32Digital.pinterface = NULL; errlogPrintf("devMpsRatesBurstDestinationRegistrar: bad portname\n"); continue; } pdpvt->asynUInt32Digital.drvPvt = pdpvt; status = pasynUInt32DigitalBase->initialize(portName, &pdpvt->asynUInt32Digital); if (status!=asynSuccess) { errlogPrintf("devMpsRatesBurstDestinationRegistrar: registerInterface failed\n"); return; } } } epicsExportRegistrar(devMpsRatesBurstDestinationRegistrar);