/* * EmulatedTiming.c * mpsLinkProcessor * * Created by Stephen Norum. * Copyright 2007 Stanford Linear Accelerator Center. All rights reserved. * */ #include #include #include #include #include #include #include #include #include #include #include #ifdef __rtems__ #include #endif #include #include #include "Timing.h" #include "TimingEmulatedEvr.h" #include "MachineStateBuffer.h" #include #include #define LINUX_MOCK_INTERRUPT_THREAD_SLEEP_SECONDS (1.0) #define RTEMS_MOCK_INTERRUPT_THREAD_SLEEP_USECONDS (2778) #define HARDWARE_TIMER (0) enum TimingEmulatedEvrSpecialValues { TEEBurstModeActive120HzIndex = 0, TEEBurstModeActive60HzIndex = 1, TEEBurstModeActive30HzIndex = 2, TEEBurstModeActive10HzIndex = 3, TEEBurstModeActive1HzIndex = 4, TEEBurstModeActiveIndexInvalid }; static MPSTimingTimeslots mpsTimeslotConfig; static epicsEventId evrDataCallbackEvent; static epicsMutexId *queuedTimingDataMutex; static epicsEventId *newEvrTimingDataEventPointer; static int *timingThreadIsProcessing; static epicsMutexId evrTimingDataMutex; static MPSTimingData evrQueuedTimingData[MPSTimingMaxTimingDataQueueLength]; static char burstModeActive[5] = {epicsFalse, epicsFalse, epicsFalse, epicsFalse, epicsFalse}; int setBurstModeActive(unsigned char rateInHz, char state) { int index = TEEBurstModeActiveIndexInvalid; switch (rateInHz) { case 120: index = TEEBurstModeActive120HzIndex; break; case 60: index = TEEBurstModeActive60HzIndex; break; case 30: index = TEEBurstModeActive30HzIndex; break; case 10: index = TEEBurstModeActive10HzIndex; break; case 1: index = TEEBurstModeActive1HzIndex; break; default: index = TEEBurstModeActiveIndexInvalid; break; } if (index == TEEBurstModeActiveIndexInvalid) { return MPS_ERROR; } burstModeActive[index] = state ? epicsTrue : epicsFalse; return MPS_SUCCESS; } int timingPrintEmulated() { 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 evrCopyTimingDataEmulated(MPSTimingData *timingDataArray) { int i; epicsMutexLock(evrTimingDataMutex); for (i = 0; i < 3; i++) { timingDataArray[i] = evrQueuedTimingData[i]; } epicsMutexUnlock(evrTimingDataMutex); return MPS_SUCCESS; } static void evrDataCallback(void *arg) { static MPSTimingData newTimingData; int i = 0; unsigned int clock = 0; epicsEventWaitStatus waitStatus; /* Initialize new timing data */ epicsTimeGetCurrent(&(newTimingData.timestamp)); newTimingData.timeslot = 6; newTimingData.pulseid = 10; newTimingData.beamRequested = epicsTrue; newTimingData.burstPulseRequested = epicsFalse; while(1) { waitStatus = epicsEventWait(evrDataCallbackEvent); if (waitStatus != epicsEventWaitOK) { errlogPrintf("Error: evrDataCallback, epicsEventWait returned %d", waitStatus); continue; } clock = (clock + 1) % 360; epicsTimeGetCurrent(&(newTimingData.timestamp)); newTimingData.timeslot = (clock % 6) + 1; /* cycle through 1 to 6 */ newTimingData.pulseid = (clock % 10) + 1; /* cycle through 1 to 10 */ if ((newTimingData.timeslot == mpsTimeslotConfig.baseRate120HzTimeslot1) || (newTimingData.timeslot == mpsTimeslotConfig.baseRate120HzTimeslot2) ) { newTimingData.baseRate120Hz = epicsTrue; newTimingData.beamRequested = epicsTrue; } else { newTimingData.baseRate120Hz = epicsFalse; newTimingData.beamRequested = epicsFalse; } /* Non-120 Hz beam is always on mpsTimeslotConfig.baseRate60HzTimeslot */ newTimingData.baseRate60Hz = !((clock + mpsTimeslotConfig.baseRate60HzTimeslot - 1) % (360 / 60)); newTimingData.baseRate30Hz = !((clock + mpsTimeslotConfig.baseRate60HzTimeslot - 1) % (360 / 30)); newTimingData.baseRate10Hz = !((clock + mpsTimeslotConfig.baseRate60HzTimeslot - 1) % (360 / 10)); newTimingData.baseRate1Hz = !((clock + mpsTimeslotConfig.baseRate60HzTimeslot - 1) % (360 / 1)); /* Burst pulse requests */ newTimingData.burstPulseRequested = ((burstModeActive[TEEBurstModeActive120HzIndex] && newTimingData.baseRate120Hz) || (burstModeActive[TEEBurstModeActive60HzIndex] && newTimingData.baseRate60Hz) || (burstModeActive[TEEBurstModeActive30HzIndex] && newTimingData.baseRate30Hz) || (burstModeActive[TEEBurstModeActive10HzIndex] && newTimingData.baseRate10Hz) || (burstModeActive[TEEBurstModeActive1HzIndex] && newTimingData.baseRate1Hz) ) ? epicsTrue : epicsFalse; /* 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, newTimingData.timestamp, newTimingData.timeslot); epicsMutexUnlock(evrTimingDataMutex); continue; } epicsMutexUnlock(*queuedTimingDataMutex); epicsMutexLock(evrTimingDataMutex); /* Shift down timing data, then add new data to i = 2 */ for (i = 0; i < 2; i++) { evrQueuedTimingData[i] = evrQueuedTimingData[i + 1]; } evrQueuedTimingData[2] = newTimingData; deviceStateMakeOk(LP_TIMING_SPEED__INDEX, newTimingData.timestamp, newTimingData.timeslot); epicsMutexUnlock(evrTimingDataMutex); epicsMutexLock(*queuedTimingDataMutex); *timingThreadIsProcessing = epicsTrue; epicsMutexUnlock(*queuedTimingDataMutex); if (*newEvrTimingDataEventPointer != 0) { epicsEventSignal(*newEvrTimingDataEventPointer); } } /* Should never reach this point */ cantProceed("Left evrDataCallback infinite loop"); } #ifndef __rtems__ static void mockInterruptThread(void *arg) { while(epicsTrue) { epicsEventSignal(evrDataCallbackEvent); /* Sleep for a while */ epicsThreadSleep(LINUX_MOCK_INTERRUPT_THREAD_SLEEP_SECONDS); } /* Should never reach this point */ cantProceed("Left mockInterruptThread infinite loop"); } #endif static void bspTimerCallback(void *arg) { epicsEventSignal(evrDataCallbackEvent); } int initializeEvrEmulated(epicsMutexId *timingDataMutexId, epicsEventId *timingDataReadyEventId, int *timingThreadIsProcessingPointer, const MPSTimingTimeslots *timeslotConfig) { int i, err; #ifdef __rtems__ unsigned int ticksPerSecond; double ticks; #endif 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("initializeEvrEmulated: unable to create evrTimingDataMutex\n"); return MPS_ERROR; } /* Create event for ISR to notify EVR data is new */ evrDataCallbackEvent = epicsEventMustCreate(epicsEventEmpty); /* Start a thread waiting on this event */ err = (int) epicsThreadCreate("evrDataCallback", epicsThreadPriorityHigh, epicsThreadGetStackSize(epicsThreadStackMedium), (EPICSTHREADFUNC) evrDataCallback, NULL); if (err == 0) { errlogPrintf("initializeEvrEmulated: could not create evrDataCallback\n"); return MPS_ERROR_THREAD_CREATION_FAILED; } #ifdef __rtems__ /* Setup a reloading timer and ISR */ err = BSP_timer_setup(HARDWARE_TIMER, bspTimerCallback, NULL, epicsTrue); if (err != 0) { errlogPrintf("initializeEvrEmulated: could not setup hardware timer. BSP_timer_setup returned %d\n", err); return MPS_ERROR; } /* Get the number of ticks per second */ ticksPerSecond = BSP_timer_clock_get(HARDWARE_TIMER); /* Start the timer */ ticks = (unsigned int) (( (double) RTEMS_MOCK_INTERRUPT_THREAD_SLEEP_USECONDS / (double) 1E6) * (double) ticksPerSecond); err = BSP_timer_start(HARDWARE_TIMER, ticks); if (err != 0) { errlogPrintf("initializeEvrEmulated: could not start hardware timer. BSP_timer_start returned %d\n", err); return MPS_ERROR; } #else /* Linux EVR interrupt thread */ err = (int) epicsThreadCreate("mockInterruptThread", epicsThreadPriorityHigh, epicsThreadGetStackSize(epicsThreadStackMedium), (EPICSTHREADFUNC) mockInterruptThread, NULL); if (err == 0) { errlogPrintf("initializeEvrEmulated: could not create mockInterruptThread\n"); return MPS_ERROR_THREAD_CREATION_FAILED; } #endif return MPS_SUCCESS; }