/* * TimingEvr.c * mpsLinkProcessor * * Created by Stephen Norum. * Copyright 2008 Stanford Linear Accelerator Center. All rights reserved. * */ #include #include #include #include #include #include #include "Timing.h" #include "TimingEvr.h" #include "MachineStateBuffer.h" #include #include static epicsMutexId *queuedTimingDataMutex; static epicsEventId *newEvrTimingDataEventPointer; static int *timingThreadIsProcessing; static epicsMutexId evrTimingDataMutex; static MPSTimingData evrQueuedTimingData[MPSTimingMaxTimingDataQueueLength]; static MPSTimingTimeslots mpsTimeslotConfig; #ifdef __rtems__ #include #include static uint32_t processTimebaseTicks; void mpsTimingInterruptShowProcessInMicroseconds() { double megahertz = (double) BSP_bus_frequency / (double) BSP_time_base_divisor / 1000.0f; printf("Timing Processing (us, ticks): %g, %u\n", processTimebaseTicks / megahertz, (unsigned int)processTimebaseTicks); } #endif /* * Testing Only!! * Do not call during on production machine. * May cause mpsEvrFiducial to lose timing data. */ int timingPrint() { int i; static MPSTimingData copy[MPSTimingMaxTimingDataQueueLength]; if (evrTimingDataMutex == 0) { return MPS_ERROR; } epicsMutexLock(evrTimingDataMutex); for (i = 0; i < MPSTimingMaxTimingDataQueueLength; i++) { copy[i] = evrQueuedTimingData[i]; } epicsMutexUnlock(evrTimingDataMutex); printf("Queued timing data (current, next, after next):\n"); mpsPrintTimingData(copy, sizeof(copy)/sizeof(copy[0])); return MPS_SUCCESS; } int evrCopyTimingData(MPSTimingData *timingDataArray) { int i; epicsMutexLock(evrTimingDataMutex); for (i = 0; i < 3; i++) { timingDataArray[i] = evrQueuedTimingData[i]; } epicsMutexUnlock(evrTimingDataMutex); return MPS_SUCCESS; } static void mpsEvrFiducial(void *arg) { int i, err; evrModifier_ta timingModifierArray; unsigned long patternStatus; MPSTimingData *currentTimingData = evrQueuedTimingData; #ifdef __rtems__ uint32_t then, now; /* Get current time from high res clock */ then = read_timebase(); #endif /* Check if timingThread has finished processing */ epicsMutexLock(*queuedTimingDataMutex); if (*timingThreadIsProcessing != epicsFalse) { /* Timing thread is still processing and is too slow! */ #warning snorum: Move this lock after the deviceStateMakeFaulted if it is OK to do so epicsMutexUnlock(*queuedTimingDataMutex); epicsMutexLock(evrTimingDataMutex); deviceStateMakeFaulted(LP_TIMING_SPEED__INDEX, currentTimingData->timestamp, currentTimingData->timeslot); epicsMutexUnlock(evrTimingDataMutex); return; } epicsMutexUnlock(*queuedTimingDataMutex); epicsMutexLock(evrTimingDataMutex); /* For i = 0 to 2, get upcoming data for upcoming timeslot (now + i) */ for (i = 0; i < 3; i++) { err = evrTimeGetFromPipeline(&(evrQueuedTimingData[i].timestamp), i, timingModifierArray, &patternStatus, 0, 0, 0); if ((err != 0) || (TIMESLOT(timingModifierArray) == 0)) { /* Call to evrTimeGetFromPipeline failed. Fill data at i with worst case data. */ setTimingDataToWorstCase(&(evrQueuedTimingData[i])); continue; } /* * Timeslot and pulse id */ evrQueuedTimingData[i].timeslot = TIMESLOT(timingModifierArray); evrQueuedTimingData[i].pulseid = PULSEID(evrQueuedTimingData[i].timestamp); /* Beam request and base rates * * 120 Hz and 60 Hz base rates are defined by timeslots. * Other beam rates are defined by modifier bits. * Lower base rates are subsets of higher base rates. * * Beam and burst pulses can only be requested on the 120 Hz base rate. */ if ((evrQueuedTimingData[i].timeslot == mpsTimeslotConfig.baseRate120HzTimeslot1) || (evrQueuedTimingData[i].timeslot == mpsTimeslotConfig.baseRate120HzTimeslot2)) { evrQueuedTimingData[i].baseRate120Hz = epicsTrue; evrQueuedTimingData[i].beamRequested = (timingModifierArray[4] & MOD5_BEAMFULL_MASK) ? epicsTrue : epicsFalse; evrQueuedTimingData[i].burstPulseRequested = (timingModifierArray[1] & EVG_BURST) ? epicsTrue : epicsFalse; if (evrQueuedTimingData[i].timeslot == mpsTimeslotConfig.baseRate60HzTimeslot) { evrQueuedTimingData[i].baseRate60Hz = epicsTrue; } else { evrQueuedTimingData[i].baseRate60Hz = epicsFalse; } } else { evrQueuedTimingData[i].baseRate120Hz = epicsFalse; evrQueuedTimingData[i].baseRate60Hz = epicsFalse; evrQueuedTimingData[i].beamRequested = epicsFalse; evrQueuedTimingData[i].burstPulseRequested = epicsFalse; } if (evrQueuedTimingData[i].baseRate60Hz) { evrQueuedTimingData[i].baseRate30Hz = (timingModifierArray[4] & MOD5_30HZ_MASK) ? epicsTrue : epicsFalse; } else { evrQueuedTimingData[i].baseRate30Hz = epicsFalse; } if (evrQueuedTimingData[i].baseRate30Hz) { evrQueuedTimingData[i].baseRate10Hz = (timingModifierArray[4] & MOD5_10HZ_MASK) ? epicsTrue : epicsFalse; } else { evrQueuedTimingData[i].baseRate10Hz = epicsFalse; } if (evrQueuedTimingData[i].baseRate10Hz) { evrQueuedTimingData[i].baseRate1Hz = (timingModifierArray[4] & MOD5_1HZ_MASK) ? epicsTrue : epicsFalse; } else { evrQueuedTimingData[i].baseRate1Hz = epicsFalse; } } deviceStateMakeOk(LP_TIMING_SPEED__INDEX, currentTimingData->timestamp, currentTimingData->timeslot); epicsMutexUnlock(evrTimingDataMutex); epicsMutexLock(*queuedTimingDataMutex); *timingThreadIsProcessing = epicsTrue; epicsMutexUnlock(*queuedTimingDataMutex); if (*newEvrTimingDataEventPointer != 0) { epicsEventSignal(*newEvrTimingDataEventPointer); } #ifdef __rtems__ /* Get current time from high res clock */ now = read_timebase(); processTimebaseTicks = now - then; #endif return; } int initializeEvr(epicsMutexId *timingDataMutexId, epicsEventId *timingDataReadyEventId, int *timingThreadIsProcessingPointer, const MPSTimingTimeslots *timeslotConfig) { int err; int i; if ((timingDataMutexId == NULL) || (timingDataReadyEventId == NULL) || (timingThreadIsProcessingPointer == NULL)) { return MPS_ERROR_INVALID_ARGUMENT; } queuedTimingDataMutex = timingDataMutexId; newEvrTimingDataEventPointer = timingDataReadyEventId; timingThreadIsProcessing = timingThreadIsProcessingPointer; for (i = 0; i < sizeof(evrQueuedTimingData)/sizeof(evrQueuedTimingData[0]); i++) { setTimingDataToWorstCase(&(evrQueuedTimingData[i])); } if (timeslotConfig == NULL) { errlogPrintf("initializeEvr: timeslot configuration must not be NULL\n"); return MPS_ERROR; } mpsTimeslotConfig = *timeslotConfig; evrTimingDataMutex = epicsMutexCreate(); if (evrTimingDataMutex == 0) { errlogPrintf("initializeEvr: unable to create evrTimingDataMutex\n"); return MPS_ERROR; } err = evrTimeRegister((FIDUCIALFUNCTION) mpsEvrFiducial, NULL); if (err != 0) { errlogPrintf("initializeEvr: unable to register fiducial callback\n"); return MPS_ERROR; } return MPS_SUCCESS; }