/* * MachineRatesBuffer.c * MPSLinkProcessor * * Created by Stephen Norum. * Copyright 2007 Stanford Linear Accelerator Center. All rights reserved. * */ #include #include #include #include #include #include #include #include "MachineRatesBuffer.h" #include "Mitigation.h" /* maxRatesBuffer valid values are MPSRateInvalid to MPSRateUnknown * burstModeBuffer valid values are MPSRateSingleShot to MPSRateBurstModeNotActive */ static MPSBeamRate maxRatesBuffer[MPSMitigationDeviceCount]; static MPSBeamRate burstModeBuffer[MPSMitigationDeviceCount]; static epicsMutexId machineRatesBufferMutex = 0; static MPSBeamDestination beamDestination = MPSDestinationInvalid; static MPSBeamDestination timingDestination = MPSDestinationInvalid; static MPSOperatingMode operatingMode = MPSModeInvalid; static double machineRates[MPSMitigationDeviceCount]; static unsigned long currentCounts[MPSMitigationDeviceCount]; static unsigned long machineCounts[MPSMitigationDeviceCount]; static unsigned int bykikOut = 0; static unsigned int BYKIK_State[3] = {epicsFalse, epicsFalse, epicsFalse}; static unsigned int BYKIKS_State[3] = {epicsFalse, epicsFalse, epicsFalse}; static unsigned int BYKIKUserOn = epicsTrue; static unsigned int BYKIKSUserOn = epicsTrue; static unsigned int isLCLS = epicsTrue; epicsUInt8 setFacilityIsLCLS() { isLCLS = epicsTrue; return MPS_SUCCESS; } epicsUInt8 setFacilityIsFACET() { isLCLS = epicsFalse; return MPS_SUCCESS; } epicsUInt8 facilityIsLCLS() { return isLCLS; } epicsUInt8 getBykikUser() { return BYKIKUserOn; } epicsUInt8 setBykikUser(unsigned int input) { BYKIKUserOn = input; return MPS_SUCCESS; } epicsUInt8 getBykikSUser() { return BYKIKSUserOn; } epicsUInt8 setBykikSUser(unsigned int input) { BYKIKSUserOn = input; return MPS_SUCCESS; } int setBykikState_LP(int new_value){ BYKIK_State[2] = BYKIK_State[1]; BYKIK_State[1] = BYKIK_State[0]; BYKIK_State[0] = new_value; return MPS_SUCCESS; } int getBykikState_LP() { return BYKIK_State[1]; } int setBykikSState_LP(int new_value){ BYKIKS_State[2] = BYKIKS_State[1]; BYKIKS_State[1] = BYKIKS_State[0]; BYKIKS_State[0] = new_value; return MPS_SUCCESS; } int getBykikSState_LP() { return BYKIKS_State[1]; } int resetMachineCounts() { int i; for(i = 0; i < MPSMitigationDeviceCount; i++) { machineRates[i] = 0; machineCounts[i] = 0; currentCounts[i] = 0; } return MPS_SUCCESS; } int resetMachineCount(MPSMitigationDevice device) { switch(device) { case MPSMitigationDevicePockelsCell: case MPSMitigationDeviceMechanicalShutter: case MPSMitigationDeviceBykik: case MPSMitigationDeviceLaserHeaterShutter: case MPSMitigationDeviceGunHxr: case MPSMitigationDeviceGunSxr: case MPSMitigationDeviceBykikS: break; default: return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } currentCounts[device] = 0; machineRates[device] = 0.; machineCounts[device] = 0; return MPS_SUCCESS; } int incrementCounter() { int i; for(i = 0; i < MPSMitigationDeviceCount; i++) { currentCounts[i]++; } return MPS_SUCCESS; } int getBykik() { return bykikOut; } int setBykik(unsigned int input) { bykikOut = input; return MPS_SUCCESS; } int updateCurrentRate(MPSMitigationDevice device) { switch(device) { case MPSMitigationDevicePockelsCell: case MPSMitigationDeviceMechanicalShutter: case MPSMitigationDeviceBykik: case MPSMitigationDeviceLaserHeaterShutter: case MPSMitigationDeviceGunHxr: case MPSMitigationDeviceGunSxr: case MPSMitigationDeviceBykikS: break; default: return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } machineCounts[device]++; machineRates[device] = ((double)machineCounts[device] / (double)currentCounts[device]) * 360.; //machineRates[device] = (double)machineCounts[device]; return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ int getCurrentRate(MPSMitigationDevice device) { int value = 0; MPSBeamRate rate; switch(device) { case MPSMitigationDevicePockelsCell: case MPSMitigationDeviceMechanicalShutter: case MPSMitigationDeviceBykik: case MPSMitigationDeviceLaserHeaterShutter: case MPSMitigationDeviceGunHxr: case MPSMitigationDeviceGunSxr: case MPSMitigationDeviceBykikS: break; default: return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } rate = maxRatesBuffer[device]; switch(rate) { case MPSRate1Hz: value = 1; break; case MPSRate10Hz: value = 10; break; case MPSRate30Hz: value = 30; break; case MPSRate60Hz: value = 60; break; case MPSRate120Hz: value = 120; break; default: value = 0; break; } return (int)value; } /* Must lock machineRatesBufferMutex before calling */ void mpsMutexLockMachineRatesBuffer() { epicsMutexLock(machineRatesBufferMutex); } void mpsMutexUnlockMachineRatesBuffer() { epicsMutexUnlock(machineRatesBufferMutex); } void mpsShowMachineRates() { int i; MPSBeamRate maxRatesBufferCopy[MPSMitigationDeviceCount]; MPSBeamRate burstModeBufferCopy[MPSMitigationDeviceCount]; const char *deviceString; const char *rateString; const char *burstString; const char *format = "%20s %8s %5s\n"; epicsMutexLock(machineRatesBufferMutex); for (i = 0; i < MPSMitigationDeviceCount; i++) { maxRatesBufferCopy[i] = maxRatesBuffer[i]; burstModeBufferCopy[i] = burstModeBuffer[i]; } epicsMutexUnlock(machineRatesBufferMutex); printf(format, "Device", "Rate", "Burst"); printf("-------------------- -------- -----\n"); for (i = 0; i < MPSMitigationDeviceCount; i++) { deviceString = MPSMitigationDeviceString(i); rateString = MPSBeamRateString(maxRatesBufferCopy[i]); switch (burstModeBufferCopy[i]) { case MPSRateBurstModeNotActive: burstString = "-"; break; case MPSRateBurstMode: burstString = "B"; break; case MPSRateSingleShot: burstString = "S"; break; default: burstString = "-"; break; } if (deviceString == NULL) { deviceString = ""; } if (rateString == NULL) { rateString = ""; } printf(format, deviceString, rateString, burstString); } } /* Must lock machineRatesBufferMutex before calling */ int setMaxRateAfterDevice(MPSBeamRate maxRate, MPSMitigationDevice device) { MPSBeamRate *buffer = NULL; switch(maxRate) { /* ---------------------------------------------------- */ /* Normal Rate Types */ /* ---------------------------------------------------- */ case MPSRate0Hz: case MPSRate1Hz: case MPSRate10Hz: case MPSRate30Hz: case MPSRate60Hz: case MPSRate120Hz: case MPSRateUnknown: case MPSRateInvalid: buffer = maxRatesBuffer; switch(device) { case MPSMitigationDevicePockelsCell: case MPSMitigationDeviceMechanicalShutter: case MPSMitigationDeviceBykik: case MPSMitigationDeviceLaserHeaterShutter: case MPSMitigationDeviceGunHxr: case MPSMitigationDeviceGunSxr: case MPSMitigationDeviceBykikS: break; default: return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } break; /* ---------------------------------------------------- */ /* Burst Rate Types */ /* ---------------------------------------------------- */ case MPSRateSingleShot: case MPSRateBurstMode: buffer = burstModeBuffer; switch(device) { case MPSMitigationDevicePockelsCell: case MPSMitigationDeviceBykik: case MPSMitigationDeviceGunHxr: case MPSMitigationDeviceGunSxr: case MPSMitigationDeviceBykikS: break; default: return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } break; /* ---------------------------------------------------- */ /* Default */ /* ---------------------------------------------------- */ default: return MPS_ERROR_INVALID_ARGUMENT; } if (maxRate < buffer[device]) { buffer[device] = maxRate; } return MPS_SUCCESS; } int clearAllBurstModes() { MPSMitigationDevice device; for (device = 0; device < MPSMitigationDeviceCount; device++) { burstModeBuffer[device] = MPSRateBurstModeNotActive; } return MPS_SUCCESS; } int setMaxRateAfterAllDevices(MPSBeamRate maxRate) { MPSMitigationDevice device; /* Check argument validity */ switch(maxRate) { case MPSRate0Hz: case MPSRate1Hz: case MPSRate10Hz: case MPSRate30Hz: case MPSRate60Hz: case MPSRate120Hz: case MPSRateSingleShot: case MPSRateBurstMode: case MPSRateInvalid: case MPSRateUnknown: break; default: return MPS_ERROR_INVALID_ARGUMENT; } for (device = 0; device < MPSMitigationDeviceCount; device++) { setMaxRateAfterDevice(maxRate, device); } return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ int setRateAfterDevice_warning_allows_any_rate(MPSBeamRate rate, MPSMitigationDevice device) { /* Check argument validity */ switch(rate) { case MPSRate0Hz: case MPSRate1Hz: case MPSRate10Hz: case MPSRate30Hz: case MPSRate60Hz: case MPSRate120Hz: case MPSRateSingleShot: case MPSRateBurstMode: case MPSRateInvalid: case MPSRateUnknown: break; default: return MPS_ERROR_INVALID_ARGUMENT; } switch(device) { case MPSMitigationDevicePockelsCell: case MPSMitigationDeviceMechanicalShutter: case MPSMitigationDeviceBykik: case MPSMitigationDeviceFuture: case MPSMitigationDeviceGunHxr: case MPSMitigationDeviceGunSxr: case MPSMitigationDeviceBykikS: break; default: return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } /* Update max rate */ maxRatesBuffer[device] = rate; return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ int setRateAfterAllDevices_warning_allows_any_rate(MPSBeamRate rate) { MPSMitigationDevice device; switch(rate) { case MPSRate0Hz: case MPSRate1Hz: case MPSRate10Hz: case MPSRate30Hz: case MPSRate60Hz: case MPSRate120Hz: case MPSRateSingleShot: case MPSRateBurstMode: case MPSRateInvalid: case MPSRateUnknown: break; default: return MPS_ERROR_INVALID_ARGUMENT; } for (device = 0; device < MPSMitigationDeviceCount; device++) { setRateAfterDevice_warning_allows_any_rate(rate, device); } return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ int getBurstModeStatusForDevice(MPSBeamRate *status, MPSMitigationDevice device) { /* Check argument validity */ if ((unsigned int) device >= MPSMitigationDeviceCount) { *status = MPSRateBurstInvalid; return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } *status = burstModeBuffer[device]; return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ int getRateAfterDevice(MPSBeamRate *rate, MPSMitigationDevice device) { /* Check argument validity */ if ((unsigned int) device >= MPSMitigationDeviceCount) { return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } *rate = maxRatesBuffer[device]; return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ int getRatesAfterAllDevices(MPSBeamRate *ratesAfterDevices) { int i; /* Return values through the maxRates pointer */ for (i = 0; i < MPSMitigationDeviceCount; i++) { ratesAfterDevices[i] = maxRatesBuffer[i]; } return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ int setBeamDestination(MPSBeamDestination destination) { if ((unsigned int) destination >= MPSNumberOfDestinations) { return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } beamDestination = destination; return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ MPSBeamDestination getBeamDestination() { return beamDestination; } /* Must lock machineRatesBufferMutex before calling */ int setTimingDestination(MPSBeamDestination destination) { if ((unsigned int) destination >= MPSNumberOfDestinations) { return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } timingDestination = destination; return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ MPSBeamDestination getTimingDestination() { return timingDestination; } /* Must lock machineRatesBufferMutex before calling */ int setOperatingMode(MPSOperatingMode mode) { if ((unsigned int) mode >= MPSNumberOfOperatingModes) { return MPS_ERROR_ARGUMENT_OUT_OF_RANGE; } operatingMode = mode; return MPS_SUCCESS; } /* Must lock machineRatesBufferMutex before calling */ MPSOperatingMode getOperatingMode() { return operatingMode; } /* Must lock machineRatesBufferMutex before calling */ int setAllRatesToMostRestrictiveAndClearBurstModes() { int err; err = setRateAfterAllDevices_warning_allows_any_rate(MPSRate0Hz); if (err != MPS_SUCCESS) { return err; } err = clearAllBurstModes(); return err; } int initializeMachineRatesBuffer() { /* Initialize mutex */ machineRatesBufferMutex = epicsMutexMustCreate(); /* Set all mitigation device rates to 0 Hz, burst mode not active */ epicsMutexLock(machineRatesBufferMutex); setAllRatesToMostRestrictiveAndClearBurstModes(); resetMachineCounts(); beamDestination = MPSDestinationInvalid; operatingMode = MPSModeInvalid; epicsMutexUnlock(machineRatesBufferMutex); return MPS_SUCCESS; }