/* * 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; 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: 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: 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: 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 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(); beamDestination = MPSDestinationInvalid; epicsMutexUnlock(machineRatesBufferMutex); return MPS_SUCCESS; }