class ChannelFaultManager: """Interface that institutes software value forcing on the system.""" def __init__(self, gatewayIPAddress=None): if (gatewayIPAddress is None): self.isfiu = Factory().GetIChannelFault("") else: self.isfiu = Factory().GetIChannelFault(gatewayIPAddress) def GetFaultList(self): """Acquires a list of all currently faulted channels.""" data = self.isfiu.GetFaultList(None, None) _RaiseException_(data[0]) return list(zip(data[1], data[2])) def GetFaultValue(self, name): """Acquires the fault value of a channel you specify.""" data = self.isfiu.GetFaultValue(name, False, 0.0) _RaiseException_(data[0]) return {'faulted': data[1], 'fault value': data[2]} def SetFaultValue(self, name, value): """Sets the fault value of the channel you specify.""" _RaiseException_(self.isfiu.SetFaultValue(name, value)) def ClearFault(self, name): """Removes the channel you specify from the fault list.""" _RaiseException_(self.isfiu.ClearFault(name)) def ClearAllFaults(self): """Clears all faults.""" _RaiseException_(self.isfiu.ClearAllFaults())
def __init__(self, name, target=None, gatewayIPAddress=None): if ((target is None) and (gatewayIPAddress is None)): self.imodel = Factory().GetIModel(name) elif (target is None): self.imodel = Factory().GetIModel(gatewayIPAddress, "", name) elif (gatewayIPAddress is None): self.imodel = Factory().GetIModel("", target, name) else: self.imodel = Factory().GetIModel(gatewayIPAddress, target, name)
def __init__(self, name, target=None, gatewayIPAddress=None): if ((target is None) and (gatewayIPAddress is None)): self.ialarm = Factory().GetIAlarm(name) elif (target is None): self.ialarm = Factory().GetIAlarm("", name, gatewayIPAddress) elif (gatewayIPAddress is None): self.ialarm = Factory().GetIAlarm(target, name, "") else: self.ialarm = Factory().GetIAlarm(target, name, gatewayIPAddress)
class MacroPlayer: def __init__(self, gatewayIPAddress=None): if (gatewayIPAddress is None): self.player = Factory().GetIMacroPlayer("") else: self.player = Factory().GetIMacroPlayer(gatewayIPAddress) def LoadMacro(self, file): """Loads a workspace macro.""" _RaiseException_(self.player.LoadMacro(file)) def PlayState(self): """Acquires the current play state.""" data = self.player.PlayState() if (data == PlayStateEnum.NotPlaying): return PyMacroPlayerState.NotPlaying elif (data == PlayStateEnum.Playing): return PyMacroPlayerState.Playing elif (data == PlayStateEnum.Paused): return PyMacroPlayerState.Paused def PlayMacro(self, mode): """Replays the loaded macro.""" if (mode == 0): _RaiseException_(self.player.PlayMacro(PlayModeEnum.IgnoreTiming)) else: _RaiseException_(self.player.PlayMacro(PlayModeEnum.UseTiming)) def Wait(self): _RaiseException_(self.player.Wait()) def PausePlaying(self): _RaiseException_(self.player.PausePlaying()) def ResumePlaying(self): _RaiseException_(self.player.ResumePlaying()) def StopPlaying(self): _RaiseException_(self.player.StopPlaying()) def GetCommandLines(self): data = self.player.GetCommandLines() _RaiseException_(data[0]) commandLines = [] for i in data[1]: data = {'seconds': i.seconds, 'cmdLine': i.cmdLine} commandLines.append(data) return commandLines
class AlarmManager2: """Interface that acquires information on the state of the server alarm.""" def __init__(self, gateway_ip_address=None): if (gateway_ip_address is None): self.iamgr = Factory().GetIAlarmManager2("") else: self.iamgr = Factory().GetIAlarmManager2(gateway_ip_address) def GetAlarmList(self, target): """Acquires a list of names of all the alarms configured in the system.""" data = self.iamgr.GetAlarmList(target, None) _RaiseException_(data[0]) values = [] for i in data[1]: values.append(i) return values def GetAlarmsStatus(self, target): """Acquires a list of alarms organized by status (high, medium, and low).""" data = self.iamgr.GetAlarmsStatus(target) _RaiseException_(data[0]) return { 'HighAlarm': data[1], 'MediumAlarm': data[2], 'LowAlarm': data[3], 'HighAlarmName': data[4], 'MedAlarmName': data[5], 'LowAlarmName': data[6] } def GetMultipleAlarmsData(self, target, alarms, timeout): """Acquires information about a list of alarms.""" tupleAlarmNames = _ConvertListParamToTuple_(alarms) data = self.iamgr.GetMultipleAlarmsData(target, tupleAlarmNames, System.UInt32(timeout), None) _RaiseException_(data[0]) temp = Alarm('') values = [] for netAlarmInfo in data[1]: values.append(temp._ConvertAlarmToDictionary_(netAlarmInfo)) return values
class AlarmManager: """Interface that acquires information on the state of the server alarm.""" def __init__(self): self.iamgr = Factory().GetIAlarmManager() def GetAlarmList(self): """Acquires a list of names of all the alarms configured in the system.""" data = [] data = self.iamgr.GetAlarmList(data) _RaiseException_(data[0]) values = [] for i in data[1]: values.append(i) return values def GetAlarmsStatus(self): """Acquires a list of alarms organized by status (high, medium, and low).""" a0 = a1 = a2 = System.Boolean(False) aname0 = aname1 = aname2 = System.String('') data = self.iamgr.GetAlarmsStatus(a0, a1, a2, aname0, aname1, aname2) _RaiseException_(data[0]) return { 'HighAlarm': data[1], 'MediumAlarm': data[2], 'LowAlarm': data[3], 'HighAlarmName': data[4], 'MedAlarmName': data[5], 'LowAlarmName': data[6] } def GetMultipleAlarmsData(self, alarms, timeout): """Acquires information about a list of alarms.""" data = self.iamgr.GetMultipleAlarmsData(list(alarms), System.UInt32(timeout), []) _RaiseException_(data[0]) temp = Alarm('') values = [] for netAlarmInfo in data[1]: values.append(temp._ConvertAlarmToDictionary_(netAlarmInfo)) return values
def WaitForNIVeriStandReady(address="localhost", secondsTimeout=120): import time start = time.time() while True: try: Factory().GetIWorkspace2(address) break except Exception: time.sleep(0.5) now = time.time() if (now - start) > secondsTimeout: raise NIVeriStandException(-307663, "Could not connect to gateway.")
class MacroRecorder: def __init__(self): self.record = Factory().GetIMacroRecorder() def StartRecording(self): _RaiseException_(self.record.StartRecording()) def StopRecording(self): _RaiseException_(self.record.StopRecording()) def ResumeRecording(self): _RaiseException_(self.record.ResumeRecording()) def SaveMacro(self, file): _RaiseException_(self.record.SaveMacro(file)) def GetCommandLines(self): data = self.record.GetCommandLines() _RaiseException_(data[0]) commandLines = [] for i in data[1]: data = {'seconds': i.seconds, 'cmdLine': i.cmdLine} commandLines.append(data) return commandLines
class Stimulus2(Stimulus): """Automates the execution of stimulus profiles.""" def __init__(self, gatewayIPAddress=None): if (gatewayIPAddress is None): self.istim = Factory().GetIStimulus2("") else: self.istim = Factory().GetIStimulus2(gatewayIPAddress) def __del__(self): self.UnreserveStimulusProfileManager() def RunStimulusProfile(self, testfile, baselogpath, timeout, autostart, stopondisconnect, parameterfiles=()): """Starts the stimulus generation you defined in the test file.""" tupleFiles = _ConvertListParamToTuple_(parameterfiles) _RaiseException_( self.istim.RunStimulusProfile(testfile, baselogpath, timeout, autostart, stopondisconnect, tupleFiles))
def __init__(self): self.iamgr = Factory().GetIAlarmManager()
from niveristand.library import wait #Import the next elements to be able to create a logging specification import clr clr.AddReference("NationalInstruments.VeriStand.ClientAPI") from NationalInstruments.VeriStand.ClientAPI import Factory from NationalInstruments.VeriStand.ClientAPI import Logging from NationalInstruments.VeriStand.ClientAPI.Logging import * from System import Array #################### ###Setup logging ### #Open Data Logging Manager Reference. We use localhost because logging takes place in the local computer Data_Logging_Manager_Ref = Factory().GetIDataLogging("localhost") #New TDMS Log File. First input is path to logging file. Second input is fileConflictOperation. 0 means create a new file with unique name TDMSLogFile_Ref = TdmsLogFile(r"C:\Users\chericks\Documents\VeriStand Projects\Engine Demo\Logs\myLog.tdms",0) #Add TDMS Group and one channel. Repeat for as many groups and channels. Group_ref = TdmsChannelGroup("myGroup") Channel_ref = TdmsChannel("myChannel","Aliases/ActualRPM") #Add channel to group Group_ref.AddChannel(Channel_ref) #Add group to TDMS file TDMSLogFile_Ref.AddChannelGroup(Group_ref) #New Data Logging Specification (TDMS) Logging_Specification_Ref = DataLoggingSpecification(TDMSLogFile_Ref)
class Stimulus: def __init__(self): self.istim = Factory().GetIStimulus() def __del__(self): self.UnreserveStimulusProfileManager() def ReserveStimulusProfileManager(self): """ Creates a task that reserves the stimulus generation server. This task prevents other clients from interrupting the stimulus generation process. """ _RaiseException_(self.istim.ReserveStimulusProfileManager()) def UnreserveStimulusProfileManager(self): """Destroys the task that reserves the stimulus generation server. Frees the server for other clients to use.""" _RaiseException_(self.istim.UnreserveStimulusProfileManager()) def GetStimulusProfileManagerState(self): """Returns the state of the stimulus generation component.""" data = self.istim.GetStimulusProfileManagerState(StimulusState.Stopped) _RaiseException_(data[0]) return self._NetStimulusStateToPy_(data[1]) def RunStimulusProfile(self, testfile, baselogpath, timeout, autostart, stopondisconnect): """Starts the stimulus generation you defined in the test file.""" _RaiseException_( self.istim.RunStimulusProfile(str(testfile), str(baselogpath), System.UInt32(timeout), bool(autostart), bool(stopondisconnect))) def StopStimulusProfile(self): """Stops the stimulus generation.""" _RaiseException_(self.istim.StopStimulusProfile()) def GetStimulusProfileFile(self): """Acquires the current stimulus definition file.""" data = self.istim.GetStimulusProfileFile("") _RaiseException_(data[0]) return data[1] def GetStimulusProfileResult(self): """ Acquires the result of stimulus generation test. Only the table test produces a test file of the result. """ data = self.istim.GetStimulusProfileResult(StimulusResult.Failed, "") _RaiseException_(data[0]) values = { 'Result': self._NetStimulusResultToPy_(data[1]), 'File': data[2] } return values def _NetStimulusStateToPy_(self, net): if (net == StimulusState.Stopped): return PyStimulusState.Stopped elif (net == StimulusState.Starting): return PyStimulusState.Starting elif (net == StimulusState.Running): return PyStimulusState.Running elif (net == StimulusState.Stopping): return PyStimulusState.Stopping else: raise ValueError def _NetStimulusResultToPy_(self, net): if (net == 0): return PyStimulusResult.NoResult elif (net == StimulusResult.Passed): return PyStimulusResult.Passed elif (net == StimulusResult.Failed): return PyStimulusResult.Failed elif (net == PyStimulusResult.Error): return PyStimulusResult.Error else: raise ValueError
class Model: """Interface that acquires information on a specific model running on the system.""" def __init__(self, name, target=None, gatewayIPAddress=None): if ((target is None) and (gatewayIPAddress is None)): self.imodel = Factory().GetIModel(name) elif (target is None): self.imodel = Factory().GetIModel(gatewayIPAddress, "", name) elif (gatewayIPAddress is None): self.imodel = Factory().GetIModel("", target, name) else: self.imodel = Factory().GetIModel(gatewayIPAddress, target, name) def GetModelExecutionState(self): """Acquires the execution time and state of the model.""" data = self.imodel.GetModelExecutionState(0.0, ModelState.Idle) _RaiseException_(data[0]) values = {'time': data[1], 'state': self._NetModelStateToPy_(data[2])} return values def SetModelExecutionState(self, command): """ Changes the current state of the model on the server. This is a request operation on the server. Even if this function executes successfully, the model state may remain unchanged in some cases. See PyModelState for command values. """ _RaiseException_( self.imodel.SetModelExecutionState( self._PyModelStateToNet_(command))) def SaveModelState(self, filepath): """Saves the current model state to the path on the target you specify in `filepath`.""" _RaiseException_(self.imodel.SaveModelState(filepath)) def RestoreModelState(self, filepath): """Restores the state of a model running on the target. Specify the path to the model file in `filepath`.""" _RaiseException_(self.imodel.RestoreModelState(filepath)) def _NetModelStateToPy_(self, net): if (net == ModelState.Running): return PyModelState.Running elif (net == ModelState.Paused): return PyModelState.Paused elif (net == ModelState.Resetting): return PyModelState.Resetting elif (net == ModelState.Idle): return PyModelState.Idle elif (net == ModelState.Stopped): return PyModelState.Stopped elif (net == ModelState.Restoring): return PyModelState.Restoring elif (net == ModelState.Saving): return PyModelState.Saving else: raise ValueError def _PyModelStateToNet_(self, py): if (py == PyModelCommand.Start): return ModelCommand.Start elif (py == PyModelCommand.Pause): return ModelCommand.Pause elif (py == PyModelCommand.Reset): return ModelCommand.Reset else: raise ValueError
class Workspace: """Interface that controls the running state of the system and accesses the channels in the system.""" def __init__(self): self.iwks = Factory().GetIWorkspace() def GetEngineState(self): """Returns the current state of the system.""" data = self.iwks.GetEngineState(0, "", "", "") _RaiseException_(data[0]) return { 'state': self._NetSystemStateToPy_(data[1]), 'workspace_file': data[2], 'systemdefinition_file': data[3], 'ip_address': data[4] } def RunWorkspaceFile(self, file, launchworkspacewindow, deploysystemdefinition, timeout, username, password): """Runs the workspace configuration file you specify. Raises an error if you call this function while a configuration is already running. You must stop all running configurations before you call this function. If this function times out, check to see if the deployment process took longer than expected and caused the operation to timeout. Use the GetEngineState function to check the status of the system. """ _RaiseException_( self.iwks.RunWorkspaceFile(file, launchworkspacewindow, deploysystemdefinition, timeout, username, password)) def StopWorkspaceFile(self, password): """Stops the execution of the currently running configuration.""" _RaiseException_(self.iwks.StopWorkspaceFile(password)) def LockWorkspaceFile(self, old_password, new_password): """ Locks the configuration that is currently running. This function will only succeed if a configuration is currently running. If this configuration was locked previously, you must enter the previous password in `old_password`. """ _RaiseException_( self.iwks.LockWorkspaceFile(old_password, new_password)) def UnlockWorkspaceFile(self, password): """Unlocks the currently running configuration.""" _RaiseException_(self.iwks.UnlockWorkspaceFile(password)) def GetSingleChannelValue(self, name): """Acquires the value of the channel you specify.""" data = 0.0 data = self.iwks.GetSingleChannelValue(name, data) _RaiseException_(data[0]) return data[1] def GetMultipleChannelValues(self, names): """Acquires values from the channels you specify.""" tuppleNames = _ConvertListParamToTuple_(names) data = self.iwks.GetMultipleChannelValues(tuppleNames, None) _RaiseException_(data[0]) values = [] for i in data[1]: values.append(i) return values def GetChannelVectorValues(self, name): """Acquires the vector value of the channel you specify.""" zero = System.UInt32(0) data = self.iwks.GetChannelVectorValues(name, zero, zero, None) _RaiseException_(data[0]) return _Convert1DARRVALTOMATRIX_(data[1], data[2], data[3]) def SetSingleChannelValue(self, name, value): """Sets the value for the channel you specify.""" _RaiseException_(self.iwks.SetSingleChannelValue(name, float(value))) def SetMultipleChannelValues(self, names, values): """Sets the value(s) for the channels you specify.""" tuppleNames = _ConvertListParamToTuple_(names) tuppleValues = _ConvertListParamToTuple_(values) _RaiseException_( self.iwks.SetMultipleChannelValues(tuppleNames, tuppleValues)) def SetChannelVectorValues(self, name, values): """ Sets the starting parameter vector value for the channel you specify. The value you specify in `values` must be a matrix data type. """ ws2 = Workspace2("") ws2.SetChannelValues([name], [values]) def GetMultipleSystemNodesData(self, names): """Acquires data from the nodes you specify.""" tuppleNames = _ConvertListParamToTuple_(names) data = self.iwks.GetMultipleSystemNodesData(tuppleNames, None) _RaiseException_(data[0]) nodes = [] for i in data[1]: nodes.append(self._ConvertNodeInfoToDictionary_(i)) return nodes def GetSystemNodeChildren(self, name): """Acquires a list of all the child nodes nested under the node you specify.""" data = self.iwks.GetSystemNodeChildren(name, None) _RaiseException_(data[0]) nodes = [] for i in data[1]: nodes.append(self._ConvertNodeInfoToDictionary_(i)) return nodes def GetSystemNodeChannelList(self, name): """ Acquires all channels of the node you specify. If you want to acquire all the channels in the system, enter "" as the node name. """ data = self.iwks.GetSystemNodeChannelList(name, None) _RaiseException_(data[0]) nodes = [] for i in data[1]: nodes.append(self._ConvertNodeInfoToDictionary_(i)) return nodes def GetAliasList(self): """Acquires all the aliases of a system.""" data = self.iwks.GetAliasList(None, None) _RaiseException_(data[0]) dict = {} for i in range(0, len(data[1])): dict[data[1][i]] = data[2][i] return dict def _NetSystemStateToPy_(self, net): if (net == SystemState.Idle): return PySystemState.Idle elif (net == SystemState.Active): return PySystemState.Active else: raise ValueError def _ConvertNodeInfoToDictionary_(self, nodeInfo): return { 'name': nodeInfo.Name, 'path': nodeInfo.FullPath, 'isChannel': nodeInfo.IsChannel, 'isReadable': nodeInfo.IsReadable, 'isWritable': nodeInfo.IsWritable, 'isScalable': nodeInfo.IsScalable, 'unit': nodeInfo.ChannelUnit }
def __init__(self, gatewayIPAddress=None): if (gatewayIPAddress is None): self.player = Factory().GetIMacroPlayer("") else: self.player = Factory().GetIMacroPlayer(gatewayIPAddress)
def __init__(self): self.record = Factory().GetIMacroRecorder()
def __init__(self, gatewayIPAddress=None): if (gatewayIPAddress is None): self.istim = Factory().GetIStimulus2("") else: self.istim = Factory().GetIStimulus2(gatewayIPAddress)
class ModelManager: """Interface that queries information on the models configured in the system.""" def __init__(self): self.modmgr = Factory().GetIModelManager() def GetModelList(self): """Returns a list of all models configured in the system.""" data = self.modmgr.GetModelList(None) _RaiseException_(data[0]) models = [] for i in data[1]: models.append(i) return models def GetParametersList(self): """Returns a list of all parameters in the system.""" data = self.modmgr.GetParametersList(None) _RaiseException_(data[0]) params = [] for i in data[1]: params.append(i) return params def GetSingleParameterValue(self, name): """Acquires the value of the parameter you specify.""" data = self.modmgr.GetSingleParameterValue(name, System.Double(0)) _RaiseException_(data[0]) return data[1] def GetMultipleParameterValues(self, names): """Acquires the value(s) of the parameters you specify.""" tupleParamNames = _ConvertListParamToTuple_(names) data = self.modmgr.GetMultipleParameterValues(tupleParamNames, None) _RaiseException_(data[0]) values = [] for i in data[1]: values.append(i) return values def GetParameterVectorValues(self, name): """Acquires the vector values of the parameter you specify.""" data = self.modmgr.GetParameterVectorValues(name, System.UInt32(0), System.UInt32(0), None) _RaiseException_(data[0]) return _Convert1DARRVALTOMATRIX_(data[1], data[2], data[3]) def SetSingleParameterValue(self, name, value): """Sets the value of the parameter you specify.""" _RaiseException_( self.modmgr.SetSingleParameterValue(name, System.Double(value))) def SetMultipleParameterValues(self, names, values): """Sets the value(s) of the parameters you specify.""" tupleParamNames = _ConvertListParamToTuple_(names) tupleParamValues = _ConvertListParamToTuple_(values) _RaiseException_( self.modmgr.SetMultipleParameterValues(tupleParamNames, tupleParamValues)) def SetParameterVectorValues(self, name, values): """ Sets a vector value for a parameter. The value you specify in `value` must be a matrix data type. """ tupleArray = _ConvertMATRIXTO1DARRVAL_(values) _RaiseException_(self.modmgr.SetParameterVectorValues( name, tupleArray))
def __init__(self, gateway_ip_address=None): if (gateway_ip_address is None): self.iamgr = Factory().GetIAlarmManager2("") else: self.iamgr = Factory().GetIAlarmManager2(gateway_ip_address)
class ModelManager2(ModelManager): """Interface that queries information on the models configured in the system.""" def __init__(self, gateway_ip_address=None): super(self.__class__, self).__init__() if (gateway_ip_address is None): self.modmgr = Factory().GetIModelManager2("") else: self.modmgr = Factory().GetIModelManager2(gateway_ip_address) def GetModelList(self, target): """Returns a list of models on the target you specify.""" data = self.modmgr.GetModelList(target, None) _RaiseException_(data[0]) models = [] for i in data[1]: models.append(i) return models def GetParametersList(self, target): """Returns a list of all parameters in the target you specify.""" data = self.modmgr.GetParametersList(target, None) _RaiseException_(data[0]) params = [] for i in data[1]: params.append(i) return params def GetSingleParameterValue(self, target, name): """Acquires the value of the parameter you specify.""" data = self.modmgr.GetSingleParameterValue(target, name, System.Double(0)) _RaiseException_(data[0]) return data[1] def GetMultipleParameterValues(self, target, names): """Acquires the value(s) of the parameters you specify.""" tupleNames = _ConvertListParamToTuple_(names) data = self.modmgr.GetMultipleParameterValues(target, tupleNames, None) _RaiseException_(data[0]) values = [] for i in data[1]: values.append(i) return values def GetParameterVectorValues(self, target, name): """Acquires the vector values of the parameter you specify.""" data = self.modmgr.GetParameterVectorValues(target, name, System.UInt32(0), System.UInt32(0), None) _RaiseException_(data[0]) return _Convert1DARRVALTOMATRIX_(data[1], data[2], data[3]) def SetSingleParameterValue(self, target, name, value): """Sets the value of the parameter you specify.""" _RaiseException_( self.modmgr.SetSingleParameterValue(target, name, System.Double(value))) def SetMultipleParameterValues(self, target, names, values): """Sets the value of the parameter(s) you specify.""" tupleNames = _ConvertListParamToTuple_(names) tupleValues = _ConvertListParamToTuple_(values) _RaiseException_( self.modmgr.SetMultipleParameterValues(target, tupleNames, tupleValues)) def SetParameterVectorValues(self, target, name, values): """Set a parameter vector values. Values are expected to be a matrix type. """ tupleArray = _ConvertMATRIXTO1DARRVAL_(values) _RaiseException_( self.modmgr.SetParameterVectorValues(target, name, tupleArray)) def SetParameterValues(self, target, names, matrixArr): """ Sets the vector value of the parameter(s) you specify. The value you specify in `matrixArr` must be a matrix data type. Sample usage ModelManager2.SetParameterValues("target1",["1By3Param","2By3Param"],[[[1,2,3]],[[1,2,3],[4,5,6]]]) """ tupleNames = _ConvertListParamToTuple_(names) dataArrayArrays = _ConvertMATRIXARRToDataArray_(matrixArr) _RaiseException_( self.modmgr.SetParameterValues(target, tupleNames, dataArrayArrays)) def UpdateParametersFromFile(self, target, parameterfiles): """Update a set of parameters specified in the parameter files.""" tupleFiles = _ConvertListParamToTuple_(parameterfiles) _RaiseException_( self.modmgr.UpdateParametersFromFile(target, tupleFiles))
def __init__(self): self.iwks = Factory().GetIWorkspace()
import clr import sys import System '''Run C:\\Users\\Public\\Documents\\National Instruments\\NI VeriStand 2017\\Examples\\Stimulus Profile\\Engine Demo\\Engine Demo.nivsproj''' sys.path.append("c:\\Program Files (x86)\\National Instruments\\VeriStand 2017\\nivs.lib\\Reference Assemblies") clr.AddReference("NationalInstruments.VeriStand.ClientAPI") clr.AddReference("NationalInstruments.VeriStand.RealTimeSequenceDefinitionApi") from NationalInstruments.VeriStand.StimulusProfileDefinitionApi import StimulusProfile from NationalInstruments.VeriStand.ClientAPI import Factory #Instance of Class Factory provides access to the NI VeriStand system fac = Factory() print(fac) #Interface to perform basic workspace operations facWork = fac.GetIWorkspace2('localhost') print(facWork) #Create StimulusProfile object and execute profile asynchronously. stimProfile = StimulusProfile("c:\\Users\\Public\\Documents\\National Instruments\\NI VeriStand 2017\\Examples\\Stimulus Profile\\Engine Demo\\Stimulus Profiles\\Basic Engine Demo\\Engine Demo Basics.nivsstimprof") stimProfile.ExecuteAsync('localhost','000') #define in out parameters chan = System.String("Targets/Controller/Simulation Models/Models/Engine Demo/Outports/RPM") out = System.Double(0) error, out = facWork.GetSingleChannelValue(chan, out) print("")
def __init__(self): self.modmgr = Factory().GetIModelManager()
class Workspace2(Workspace): """Interface that controls the running state of the system and accesses the channels in the system.""" def __init__(self, gatewayIPAddress=None): if (gatewayIPAddress is None): self.iwks = Factory().GetIWorkspace2("") else: self.iwks = Factory().GetIWorkspace2(gatewayIPAddress) def GetSystemState(self): """Returns the current state of the system.""" data = self.iwks.GetSystemState(0, "", None) _RaiseException_(data[0]) targets = [] for target in data[3]: targets.append(target) return { 'state': self._NetSystemStateToPy_(data[1]), 'systemdefinition_file': data[2], 'targets': tuple(targets) } def ConnectToSystem(self, systemdefinition_file, deploy, timeout): """Connects the VeriStand Gateway to one or more targets running on the System Definition file you specify.""" _RaiseException_( self.iwks.ConnectToSystem(systemdefinition_file, System.Boolean(deploy), System.UInt32(timeout))) def DisconnectFromSystem(self, password, undeploy_system_definition): """Disconnects the VeriStand Gateway from the targets.""" _RaiseException_( self.iwks.DisconnectFromSystem(password, undeploy_system_definition)) def LockConnection(self, old_password, new_password): """ Locks the current VeriStand Gateway connection. If the connection was locked previously, you must enter the previous password in `old_password`. """ _RaiseException_(self.iwks.LockConnection(old_password, new_password)) def UnlockConnection(self, password): """Unlocks the current VeriStand Gateway connection.""" _RaiseException_(self.iwks.UnlockConnection(password)) def StartDataLogging(self, configuration_name, logInfo): """Starts logging data to the configuration you specify.""" _RaiseException_( self.iwks.StartDataLogging(configuration_name, logInfo)) def StopDataLogging(self, configuration_name): """Terminates data logging for the configuration you specify.""" _RaiseException_(self.iwks.StopDataLogging(configuration_name)) def SetChannelValues(self, channels, newValues): """Sets the value for the channels you specify. The `newValues` parameter accepts scalar, vector, and matrix data types. """ tupleChannelNames = _ConvertListParamToTuple_(channels) tupleArray = _ConvertMATRIXARRToDataArray_(newValues) _RaiseException_( self.iwks.SetChannelValues(tupleChannelNames, tupleArray))
def __init__(self, gateway_ip_address=None): super(self.__class__, self).__init__() if (gateway_ip_address is None): self.modmgr = Factory().GetIModelManager2("") else: self.modmgr = Factory().GetIModelManager2(gateway_ip_address)
def __init__(self, gatewayIPAddress=None): if (gatewayIPAddress is None): self.iwks = Factory().GetIWorkspace2("") else: self.iwks = Factory().GetIWorkspace2(gatewayIPAddress)
def __init__(self, gatewayIPAddress=None): if (gatewayIPAddress is None): self.isfiu = Factory().GetIChannelFault("") else: self.isfiu = Factory().GetIChannelFault(gatewayIPAddress)
class Alarm: """Interface that queries information on a configured alarm.""" def __init__(self, name, target=None, gatewayIPAddress=None): if ((target is None) and (gatewayIPAddress is None)): self.ialarm = Factory().GetIAlarm(name) elif (target is None): self.ialarm = Factory().GetIAlarm("", name, gatewayIPAddress) elif (gatewayIPAddress is None): self.ialarm = Factory().GetIAlarm(target, name, "") else: self.ialarm = Factory().GetIAlarm(target, name, gatewayIPAddress) def GetAlarmData(self, timeout): """Acquires the alarm data.""" data = self.ialarm.GetAlarmData(None, System.UInt32(timeout)) _RaiseException_(data[0]) return self._ConvertAlarmToDictionary_(data[1]) def SetAlarmData(self, alarmDict): """ Sets the alarm data. DEPRECATED function. This function does not support the Priority Number field. Use SetAlarmData2() instead. """ netAlarmInfo = self._ConvertDictionaryToAlarm_(alarmDict) _RaiseException_(self.ialarm.SetAlarmData(netAlarmInfo)) def SetAlarmData2(self, alarmDict): """Modifies an alarm in the system.""" netAlarmInfo = self._ConvertDictionaryToAlarm2_(alarmDict) _RaiseException_(self.ialarm.SetAlarmData(netAlarmInfo)) def SetEnabledState(self, enabled): """Enables or disables the current alarm.""" _RaiseException_(self.ialarm.SetEnabledState(enabled)) def SetAlarmMode(self, mode): """Changes the mode of this alarm. See PyAlarmMode for possible values.""" _RaiseException_( self.ialarm.SetAlarmMode(self._PyAlarmModeToNet_(mode))) def _NetAlarmPriorityToPy_(self, net): if (net == AlarmPriority.Low): return PyAlarmPriority.Low elif (net == AlarmPriority.Medium): return PyAlarmPriority.Medium elif (net == AlarmPriority.High): return PyAlarmPriority.High else: raise ValueError def _PyAlarmPriorityToNet_(self, py): if (py == PyAlarmPriority.Low): return AlarmPriority.Low elif (py == PyAlarmPriority.Medium): return AlarmPriority.Medium elif (py == PyAlarmPriority.High): return AlarmPriority.High else: raise ValueError def _NetAlarmStateToPy_(self, net): if (net == AlarmState.Disabled): return PyAlarmState.Disabled elif (net == AlarmState.Enabled): return PyAlarmState.Enabled elif (net == AlarmState.Tripped): return PyAlarmState.Tripped elif (net == AlarmState.DelayedTripped): return PyAlarmState.DelayedTripped elif (net == AlarmState.Indicate): return PyAlarmState.Indicate else: raise ValueError def _PyAlarmStateToNet_(self, py): if (py == PyAlarmState.Disabled): return AlarmState.Disabled elif (py == PyAlarmState.Enabled): return AlarmState.Enabled elif (py == PyAlarmState.Tripped): return AlarmState.Tripped elif (py == PyAlarmState.DelayedTripped): return AlarmState.DelayedTripped elif (py == PyAlarmState.Indicaet): return AlarmState.Indicate else: raise ValueError def _NetAlarmModeToPy_(self, net): if (net == AlarmMode.Normal): return PyAlarmMode.Normal elif (net == AlarmMode.IndicateOnly): return PyAlarmMode.IndicateOnly else: raise ValueError def _PyAlarmModeToNet_(self, py): if (py == PyAlarmMode.Normal): return AlarmMode.Normal elif (py == PyAlarmMode.IndicateOnly): return AlarmMode.IndicateOnly else: raise ValueError def _ConvertAlarmToDictionary_(self, alarm): return { 'WatchChannel': alarm.WatchChannel, 'HighLimitIsConstant': alarm.HighLimitIsConstant, 'HighLimit': alarm.HighLimit, 'HighLimitChannel': alarm.HighLimitChannelName, 'LowLimitIsConstant': alarm.LowLimitIsConstant, 'LowLimit': alarm.LowLimit, 'LowLimitChannel': alarm.LowLimitChannelName, 'DelayDuration': alarm.DelayDuration, 'TripValue': alarm.TripValue, 'ProcedureName': alarm.ProcedureName, 'Priority': self._NetAlarmPriorityToPy_(alarm.Priority), 'PriorityNumber': alarm.PriorityNumber, 'State': self._NetAlarmStateToPy_(alarm.State), 'Mode': self._NetAlarmModeToPy_(alarm.Mode), 'GroupNumber': alarm.GroupNumber, 'Name': alarm.Name, 'FullName': alarm.FullName } def _ConvertDictionaryToAlarm_(self, alarm): net = AlarmInfo() net.WatchChannel = alarm['WatchChannel'] net.HighLimitIsConstant = alarm['HighLimitIsConstant'] net.HighLimit = alarm['HighLimit'] net.HighLimitChannelName = alarm['HighLimitChannel'] net.LowLimitIsConstant = alarm['LowLimitIsConstant'] net.LowLimit = alarm['LowLimit'] net.LowLimitChannelName = alarm['LowLimitChannel'] net.DelayDuration = alarm['DelayDuration'] net.TripValue = alarm['TripValue'] net.ProcedureName = alarm['ProcedureName'] net.Priority = self._PyAlarmPriorityToNet_(alarm['Priority']) net.State = self._PyAlarmStateToNet_(alarm['State']) net.Mode = self._PyAlarmModeToNet_(alarm['Mode']) return net def _ConvertDictionaryToAlarm2_(self, alarm): net = AlarmInfo() net.WatchChannel = alarm['WatchChannel'] net.HighLimitIsConstant = alarm['HighLimitIsConstant'] net.HighLimit = alarm['HighLimit'] net.HighLimitChannelName = alarm['HighLimitChannel'] net.LowLimitIsConstant = alarm['LowLimitIsConstant'] net.LowLimit = alarm['LowLimit'] net.LowLimitChannelName = alarm['LowLimitChannel'] net.DelayDuration = alarm['DelayDuration'] net.TripValue = alarm['TripValue'] net.ProcedureName = alarm['ProcedureName'] net.PriorityNumber = alarm['PriorityNumber'] net.State = self._PyAlarmStateToNet_(alarm['State']) net.Mode = self._PyAlarmModeToNet_(alarm['Mode']) return net
def __init__(self): self.istim = Factory().GetIStimulus()
def _get_factory(): global factory if not factory: factory = Factory() return factory