def accessSignal( ): ######Might not be needed. setSignal accesses signal control """Access subsystem by subsystem Id (one value at a time for now)""" acquire.connectToModel() subSystemList = OpalApiPy.GetSubsystemList() # Displays available subSystems along with their ID and value. subSystemSignals = OpalApiPy.GetControlSignalsDescription() systemList = [subSystemSignals] print("****************Available Signals******************") for systems in systemList: systemInfo = systems for signal in systemInfo: signalType, subSystemId, path, signalName, reserved, readonly, value = signal print("SubSystem Name:{} SubSystemID:{} SignalName:{} Value:{}". format(path, subSystemId, signalName, value)) chooseId = (int(raw_input("Choose subsystem Id to be accessed: "))) OpalApiPy.GetSignalControl(chooseId, 1) print "Subsystem %s control accessed." % chooseId signalType, subSystemId, path, label, reserved, readonly, value = subSystemSignals[ chooseId - 1] print( "Subsystem Name:{} Signal Name:{} SignalID:{} ReadOnly:{} Value:{}". format(path, label, chooseId, readonly, value))
def getSyncClockPath( project, model): #ADDED To acquisition thread class CAN POSSIBLY REMOVE """Returns model clock path for asynchronous acquisition""" acquire.connectToModel(project, model) projectPath, modelName = OpalApiPy.GetCurrentModel() modelName = os.path.splitext(modelName) clockpath = modelName[0] + '/sm_master/clock/port1' simulationTime = OpalApiPy.GetSignalsByName(clockpath) return simulationTime
def acquisitionSignalsParse(project, model): """Parses acquisition signals from main signal description list. Designed for use with setting IdxVgs and Varheader in ePhasorsim acquisition port selection""" acquire.connectToModel(project, model) allSignals = list(OpalApiPy.GetSignalsDescription()) ephasor_port_out = [] for signal in allSignals: if signal[0] == 0: ephasor_port_out.append(signal[3]) OpalApiPy.Disconnect() return ephasor_port_out
def run(self): print "Thread- " + self.threadName self.lock.acquire() try: acquire.connectToModel(self.project, self.model) modelState, realTimeFactor = OpalApiPy.GetModelState() self.lock.release() except: print 'Could not connect thread ' + self.threadName else: while (modelState == OpalApiPy.MODEL_RUNNING and self.kill.is_set() is False ): #or modelState == OpalApiPy.MODEL_PAUSED): if modelState == OpalApiPy.MODEL_PAUSED and self.acq_wait.is_set( ) is False: #self.acq_wait.clear() #OpalApiPy.Disconnect() logging.warning('Thread Acq {} Paused '.format( self.threadName)) self.acq_wait.wait(1) self.acq_wait.set() logging.warning('Thread Acq {} Resumed '.format( self.threadName)) else: try: self.lock.acquire() acqList = OpalApiPy.GetAcqGroupSyncSignals( self.GroupNumber - 1, 0, 0, 1, 1) self.lock.release() except: logging.warning('<Acquisition Not Available>') break sigVals, monitorInfo, simTimeStep, endFrame = acqList missedData, offset, self.simulationTime, self.sampleSec = monitorInfo if (self.interval <= self.simulationTime - self.lastAcqTime): if (self.sample_time_error <= self.simulationTime - self.lastAcqTime): logging.warning( '<Acquisition sample step missed at {}>'.format( self.simulationTime)) self.lastAcqTime = self.simulationTime else: # self.lock.acquire() self.condition.acquire() self.dataList.dataValues.append(tuple(sigVals)) self.condition.notifyAll() self.condition.release() # self.lock.release() self.lastAcqTime = self.simulationTime modelState, realTimeFactor = OpalApiPy.GetModelState() self.kill.set() #OpalApiPy.Disconnect() print "Thread- " + self.threadName + " Exited"
def accessAllSignals( ): ######Might not be needed since set signal overrides signalControl """"Gives user access to models's control signals. One client API granted signal control at a time""" subsystemId = 0 # 0 takes control of all subsystems signalControl = 0 # requests signal control when value == 1 # Connect to model if connection is not already made acquire.connectToModel() modelState, realTimeMode = OpalApiPy.GetModelState() try: if (modelState == OpalApiPy.MODEL_RUNNING): # Access signal control signalControl = 1 OpalApiPy.GetSignalControl(subsystemId, signalControl) print "Signal control accessed" else: print "Model state not ready for signal access" finally: print "Release signal control after changing values"
def run(self): print "Thread- " + self.threadName self.lock.acquire() try: acquire.connectToModel(self.project, self.model) modelState, realTimeFactor = OpalApiPy.GetModelState() self.lock.release() except: print 'Could not connect thread ' + self.threadName else: lastIndex = 1 # while(modelState == OpalApiPy.MODEL_RUNNING):#or modelState == OpalApiPy.MODEL_PAUSED): while self.kill.is_set() is False: lastEntry = len(self.dataList.dataValues) # if((lastEntry != lastIndex) & (len(self.dataList.dataValues) != 0)): if modelState == OpalApiPy.MODEL_PAUSED and self.acq_wait.is_set( ) is False: # self.acq_wait.clear() logging.warning('Thread Acq {} Paused '.format( self.threadName)) self.acq_wait.wait(1) self.acq_wait.set() logging.warning('Thread Acq {} Resumed '.format( self.threadName)) # break if lastEntry != 0: # self.lock.acquire() self.condition.acquire() self.lastAcq = self.dataList.dataValues[lastIndex - 1] self.new_data = True self.condition.wait() self.condition.release() lastIndex = lastEntry # self.lock.release() # modelState, realTimeFactor = OpalApiPy.GetModelState() #OpalApiPy.Disconnect() print "Thread- " + self.threadName + " Exited"
def run(self): #Each thread must connect itself to the model through the acquire module acquire.connectToModel(self.project, self.model) self.projectPath, self.modelName = OpalApiPy.GetCurrentModel() modelName = os.path.splitext(self.modelName) #This is the default clock path as long as the user adds a clock to the sm_master for #time keeping if asynchronous data acquisition is needed. clockpath = modelName[0] + '/sm_master/clock/port1' modelState, realTimeFactor = OpalApiPy.GetModelState() while (modelState == OpalApiPy.MODEL_RUNNING): # Thread continues to get time until model is paused or stoped #Blocks GetSignalsByName process from other threads until time thread is done self.lock.acquire() self.simulationClock = OpalApiPy.GetSignalsByName(clockpath) # print"Simulation Time is %s" % self.simulationClock self.lock.release() modelState, realTimeFactor = OpalApiPy.GetModelState() sleep(self.interval) #Each thread must also disconnect from the API after its work has finished. OpalApiPy.Disconnect() print "Thread- " + self.threadName + " Exited"
def run(self): print "Thread- " + self.threadName acquire.connectToModel(self.project, self.model) modelState, realTimeFactor = OpalApiPy.GetModelState() clockTime = simulationTimeThread(self.project, self.model, self.interval) # clockTime.setDaemon(True) clockTime.start() clockTime.join(1) simulationClock = clockTime.simulationClock previousAcqClock = 0 while (modelState == OpalApiPy.MODEL_RUNNING): if (self.interval < (simulationClock - previousAcqClock)): #print"simclock %s" % simulationClock #print"prev acq clock %s" % previousAcqClock self.lock.acquire() #print"Lock acquired by %s" %self.threadName acqList = OpalApiPy.GetAcqGroupSyncSignals( self.GroupNumber - 1, 0, 0, 1, self.interval) sigVals, monitorInfo, simTimeStep, endFrame = acqList # dataList = DataList(self.GroupNumber) self.dataList.dataValues.append(tuple(sigVals)) #print"Lock Released by %s" %self.threadName self.lock.release() modelState, realTimeFactor = OpalApiPy.GetModelState() previousAcqClock = simulationClock #print"Thread Sleeping" #sleep(self.interval) #print"Thread UP" else: modelState, realTimeFactor = OpalApiPy.GetModelState() simulationClock = clockTime.simulationClock #OpalApiPy.Disconnect() print "Thread- " + self.threadName + " Exited"
def syncAcqReturnInfo( GroupNumber, interval ): ## Useful tool for wholistic information for acquisition group """Performs data acquisition at the specified time interval if the model is running, until the model stops running""" #Data Acquisition parameters acqGroup = GroupNumber - 1 synchronization = 0 interpolation = 0 threshold = 1 acqTimeStep = 0.001 dataRequestTime = 0 acqControl = 1 acquire.connectToModel('ephasorex2', 'phasor01_IEEE39') projectPath, modelName = OpalApiPy.GetCurrentModel() modelName = os.path.splitext(modelName) clockpath = modelName[0] + '/sm_master/clock/port1' simulationClock = OpalApiPy.GetSignalsByName(clockpath) previousAcqClock = 0 print(simulationClock) # try: modelState, realTimeMode = OpalApiPy.GetModelState() print "model state %s" % modelState OpalApiPy.GetAcquisitionControl(acqControl, GroupNumber) numTriggers = 0 while (modelState == OpalApiPy.MODEL_RUNNING): simulationClock = OpalApiPy.GetSignalsByName(clockpath) if (interval < (simulationClock - previousAcqClock)): print "simclock %s" % simulationClock print "prev acq clock %s" % previousAcqClock previousAcqClock = simulationClock acqList = OpalApiPy.GetAcqGroupSyncSignals(acqGroup, synchronization, interpolation, \ threshold, acqTimeStep) sigVals, monitorInfo, simTimeStep, endFrame = acqList missedData, offset, simTime, sampleSec = monitorInfo # sets async data acquisiion to group #,rearm trigger after S seconds for items in monitorInfo: print("missed Data:{} offset:{} simTime:{} sampleSec:{}". format(missedData, offset, simTime, sampleSec)) portID = 1 for item in sigVals: print("ID:{} Value:{} ".format(portID, item)) # sampleTimeInterval = OpalApiPy.GetAcqSampleTime(1) # print("Sample acq interval", sampleTimeInterval) portID += 1 numTriggers += 1 print "Acquisition triggered %s times" % numTriggers modelState, realTimeMode = OpalApiPy.GetModelState() else: print "Interval Range not exceeded" modelState, realTimeMode = OpalApiPy.GetModelState() # previousAcqClock = simulationClock if (modelState != OpalApiPy.MODEL_RUNNING): print "Model must be running to trigger data acquisition" OpalApiPy.GetAcquisitionControl(acqControl, GroupNumber) print "Group acquisition control released" OpalApiPy.Disconnect()