def __init__(self, manager, config, name): self.config = config self.manager = manager self.hasPowerIndicator = False self.hasShutter = False self.hasTriggerableShutter = False self.hasQSwitch = False self.hasPCell = False self.hasTunableWavelength = False self.params = { 'expectedPower': config.get('power', None), ## Expected output 'currentPower': None, ## Last measured output power 'scopeTransmission': None, ## percentage of output power that is transmitted to slice 'tolerance': 10.0, ## in % 'useExpectedPower': True, 'powerAlert': True ## set True if you want changes in output power to raise an error } daqConfig = { } ### DAQ generic needs to know about powerIndicator, pCell, shutter, qswitch if 'powerIndicator' in config: self.hasPowerIndicator = True #### name of powerIndicator is config['powerIndicator']['channel'][0] #daqConfig['powerInd'] = {'channel': config['powerIndicator']['channel'], 'type': 'ai'} if 'shutter' in config: daqConfig['shutter'] = config['shutter'] self.hasTriggerableShutter = True self.hasShutter = True if 'qSwitch' in config: daqConfig['qSwitch'] = config['qSwitch'] self.hasQSwitch = True if 'pCell' in config: daqConfig['pCell'] = config['pCell'] self.hasPCell = True daqConfig['power'] = { 'type': 'ao', 'units': 'W' } ## virtual channel used for creating control widgets DAQGeneric.__init__(self, manager, daqConfig, name) OptomechDevice.__init__(self, manager, config, name) self.lock = Mutex(QtCore.QMutex.Recursive) self.variableLock = Mutex(QtCore.QMutex.Recursive) self.calibrationIndex = None self.pCellCalibration = None self.getPowerHistory() #self.scope = manager.getDevice(self.config['scope']) #self.scope.sigObjectiveChanged.connect(self.objectiveChanged) self.sigGlobalSubdeviceChanged.connect( self.opticStateChanged ) ## called when objectives/filters have been switched manager.declareInterface(name, ['laser'], self) manager.sigAbortAll.connect(self.closeShutter)
def __init__(self, manager, config, name): try: import MMCorePy except ImportError: if sys.platform != 'win32': raise # MM does not install itself to standard path. User should take care of this, # but we can make a guess.. path = config.get('path', 'C:\\Program Files\\Micro-Manager-1.4') sys.path.append(path) os.environ['PATH'] = os.environ['PATH'] + ';' + path try: import MMCorePy finally: sys.path.pop() self.camName = str(name) # we will use this name as the handle to the MM camera self.mmc = MMCorePy.CMMCore() self._triggerProp = None # the name of the property for setting trigger mode self._triggerModes = ({}, {}) # forward and reverse mappings for the names of trigger modes self._binningMode = None # 'x' or 'xy' for binning strings like '1' and '1x1', respectively self.camLock = Mutex(Mutex.Recursive) ## Lock to protect access to camera self._config = config Camera.__init__(self, manager, config, name) ## superclass will call setupCamera when it is ready. self.acqBuffer = None self.frameId = 0 self.lastFrameTime = None
def __init__(self, dm, config, name): Device.__init__(self, dm, config, name) self.config = config self.lock = Mutex(QtCore.QMutex.Recursive) self.port = config['port'] self.scale = config['scale'] self.pos = [0, 0] self.buttons = [0, 0] ## Reload the last known state of the mouse if it was last modified recently enough self.stateFile = os.path.join('devices', self.name + "_last_state.cfg") state = dm.readConfigFile(self.stateFile) if state != {} and time.time() - state.get('time', 0) < 36000: self.pos = state['pos'] self.buttons = state['buttons'] self.mThread = MouseThread(self, { 'pos': self.pos[:], 'btns': self.buttons[:] }) self.mThread.sigPositionChanged.connect(self.posChanged) self.mThread.sigButtonChanged.connect(self.btnChanged) #self.proxy1 = proxyConnect(None, self.sigPositionChanged, self.storeState, 3.0) ## wait 3 seconds before writing changes #self.proxy2 = proxyConnect(None, self.sigSwitchChanged, self.storeState, 3.0) self.proxy1 = SignalProxy(self.sigPositionChanged, slot=self.storeState, delay=3.0) self.proxy2 = SignalProxy(self.sigSwitchChanged, slot=self.storeState, delay=3.0) self.mThread.start()
def __init__(self, dev, driver, lock): Thread.__init__(self) self.lock = Mutex(QtCore.QMutex.Recursive) self.dev = dev self.driver = driver self.driverLock = lock self.cmds = {}
def __init__(self): Thread.__init__(self) self.prot = None self._stop = False self._frame = None self._paused = False self.lock = Mutex(recursive=True)
def __init__(self, dm, config, name): Device.__init__(self, dm, config, name) OptomechDevice.__init__(self, dm, config, name) self.config = config self.lock = Mutex(QtCore.QMutex.Recursive) self.switchDevice = None self.currentSwitchPosition = None self.currentObjective = None self._focusDevice = None self._positionDevice = None self._surfaceDepth = None self.objectives = collections.OrderedDict() ## Format of self.objectives is: ## { ## switchPosition1: {objName1: objective1, objName2: objective, ...}, ## switchPosition2: {objName1: objective1, objName2: objective, ...}, ## } for k1, objs in config['objectives'].iteritems( ): ## Set default values for each objective self.objectives[k1] = collections.OrderedDict() for k2, o in objs.iteritems(): obj = Objective(o, self, (k1, k2)) self.objectives[k1][k2] = obj #obj.sigTransformChanged.connect(self.objectiveTransformChanged) ## Keep track of the objective currently in use for each position ## Format is: { switchPosition1: objective1, ... } self.selectedObjectives = collections.OrderedDict([ (i, self.objectives[i].values()[0]) for i in self.objectives ]) for obj in self.selectedObjectives.values(): self.addSubdevice(obj) ## if there is a light source, configure it here if 'lightSource' in config: self.lightSource = dm.getDevice(config['lightSource']) self.lightSource.sigLightChanged.connect(self._lightChanged) else: self.lightSource = None ## If there is a switch device, configure it here if 'objectiveSwitch' in config: self.switchDevice = dm.getDevice( config['objectiveSwitch'][0]) ## Switch device self.objSwitchId = config['objectiveSwitch'][1] ## Switch ID #self.currentSwitchPosition = str(self.switchDevice.getSwitch(self.objSwitchId)) self.switchDevice.sigSwitchChanged.connect( self.objectiveSwitchChanged) self.objectiveSwitchChanged() else: self.setObjectiveIndex(0) cal = self.readConfigFile('calibration') if 'surfaceDepth' in cal: self.setSurfaceDepth(cal['surfaceDepth']) dm.declareInterface(name, ['microscope'], self)
def __init__(self, dm, config, name): Device.__init__(self, dm, config, name) OptomechDevice.__init__(self, dm, config, name) # total device transform will be composed of a base transform (defined in the config) # and a dynamic translation provided by the hardware. self._baseTransform = Qt.QMatrix4x4(self.deviceTransform()) self._stageTransform = Qt.QMatrix4x4() self._invStageTransform = Qt.QMatrix4x4() self.config = config self.lock = Mutex(Qt.QMutex.Recursive) self.pos = [0] * 3 self._defaultSpeed = 'fast' self.pitch = config.get('pitch', 27) self.setFastSpeed(config.get('fastSpeed', 1e-3)) self.setSlowSpeed(config.get('slowSpeed', 10e-6)) # used to emit signal when position passes a threshold self.switches = {} self.switchThresholds = {} for name, spec in config.get('switches', {}).items(): self.switches[name] = None self.switchThresholds[name] = spec self._limits = [(None, None), (None, None), (None, None)] self._progressDialog = None self._progressTimer = Qt.QTimer() self._progressTimer.timeout.connect(self.updateProgressDialog) dm.declareInterface(name, ['stage'], self)
def __init__(self): QtCore.QObject.__init__(self) if DataManager.INSTANCE is not None: raise Exception("Attempted to create more than one DataManager!") DataManager.INSTANCE = self self.cache = {} self.lock = Mutex(QtCore.QMutex.Recursive)
def __init__(self): self.cams = {} self.lock = Mutex() #self.pvcam = windll.Pvcam32 if _PVCamClass.PVCAM_CREATED: raise Exception( "Will not create another pvcam instance--use the pre-existing PVCam object." ) init = LIB.pvcam_init()() if init < 1: raise Exception( "Could not initialize pvcam library (pl_pvcam_init): %s" % self.error()) # This should happen before every new exposure (?) if LIB.exp_init_seq()() < 1: raise Exception( "Could not initialize pvcam library (pl_exp_init_seq): %s" % self.error()) _PVCamClass.PVCAM_CREATED = True global externalParams self.paramTable = OrderedDict() for p in externalParams: self.paramTable[p] = self.paramFromString(p) atexit.register(self.quit)
def __init__(self, manager): Qt.QMainWindow.__init__(self) self.setWindowTitle("Log") path = os.path.dirname(__file__) self.setWindowIcon(Qt.QIcon(os.path.join(path, 'logIcon.png'))) self.wid = LogWidget(self, manager) self.wid.ui.input = Qt.QLineEdit() self.wid.ui.gridLayout.addWidget(self.wid.ui.input, 2, 0, 1, 3) self.wid.ui.dirLabel.setText("Current Storage Directory: None") self.setCentralWidget(self.wid) self.resize(1000, 500) self.manager = manager #global WIN global WIN WIN = self self.msgCount = 0 self.logCount = 0 self.logFile = None configfile.writeConfigFile( '', self.fileName() ) ## start a new temp log file, destroying anything left over from the last session. self.buttons = [ ] ## weak references to all Log Buttons get added to this list, so it's easy to make them all do things, like flash red. self.lock = Mutex() self.errorDialog = ErrorDialog() self.wid.ui.input.returnPressed.connect(self.textEntered) self.sigLogMessage.connect(self.queuedLogMsg, Qt.Qt.QueuedConnection)
def __init__(self, deviceManager, config, name): QtCore.QObject.__init__(self) self._lock_ = Mutex(QtCore.QMutex.Recursive) ## no, good idea self._lock_tb_ = None self.dm = deviceManager self.dm.declareInterface(name, ['device'], self) self._name = name
def __init__(self, dev): self.dev = dev self.lock = Mutex(recursive=True) self.stopped = False self.interval = 0.3 Thread.__init__(self)
def __init__(self, dm, config, name): Device.__init__(self, dm, config, name) OptomechDevice.__init__(self, dm, config, name) self.scopeDev = None self.currentFilter = None p = self while p is not None: p = p.parentDevice() if isinstance(p, Microscope): self.scopeDev = p self.port = config[ 'port'] ## windows com ports start at COM1, pyserial ports start at 0 self.baud = config.get('baud', 115200) #self.positionLabels = config.get('postionLabels') self.driver = FilterWheelDriver(self.port, self.baud) self.driverLock = Mutex( QtCore.QMutex.Recursive) ## access to low level driver calls self.filterWheelLock = Mutex( QtCore.QMutex.Recursive) ## access to self.attributes self.filters = OrderedDict() ## Format of self.filters is: ## { ## filterWheelPosition1: {filterName: filter}, ## filterWheelPosition2: {filterName: filter}, ## } nPos = self.getPositionCount() for k in range(nPos): ## Set value for each filter filt = Filter(config['filters'], self, k) self.filters[k] = filt #print self.filters.values() #print self.filters[1].name(), self.filters[1].description() #if len(self.positionLabels) != self.getPositionCount(): # raise Exception("Number of FilterWheel positions %s must correspond to number of labels!" % self.getPositionCount()) with self.driverLock: self.currentFWPosition = self.driver.getPos() self.currentFilter = self.getFilter() self.fwThread = FilterWheelThread(self, self.driver, self.driverLock) self.fwThread.fwPosChanged.connect(self.positionChanged) self.fwThread.start()
def __init__(self, ui): self.ui = ui self.manager = ui.manager self.clampName = ui.clampName Thread.__init__(self) self.lock = Mutex(QtCore.QMutex.Recursive) self.stopThread = True self.paramsUpdated = True
def __init__(self, path, manager): QtCore.QObject.__init__(self) self.manager = manager self.delayedChanges = [] self.path = os.path.abspath(path) self.parentDir = None self.lock = Mutex(QtCore.QMutex.Recursive) self.sigproxy = SignalProxy(self.sigChanged, slot=self.delayedChange)
def __init__(self, laserDev, scannerDev): Thread.__init__(self) self._abort = False self._video = True self._closeShutter = True # whether to close shutter at end of acquisition self.lock = Mutex(recursive=True) self.manager = acq4.Manager.getManager() self.laserDev = laserDev self.scannerDev = scannerDev
def __init__(self, *args, **kargs): self.camLock = Mutex(Mutex.Recursive) ## Lock to protect access to camera self.ringSize = 50 Camera.__init__(self, *args, **kargs) ## superclass will call setupCamera when it is ready. self.acqBuffer = None self.frameId = 0 self.lastIndex = None self.lastFrameTime = None self.stopOk = False
def __init__(self, task, frames, daqResult): self.lock = Mutex(recursive=True) self._task = task self._frames = frames self._daqResult = daqResult self._marr = None self._arr = None self._frameTimes = None self._frameTimesPrecise = False
def __init__(self, dev, cmd, parentTask): DeviceTask.__init__(self, dev, cmd, parentTask) self.cmd = cmd self.daqTasks = [] self.spotSize = None # We use this flag to exit from the sleep loop in start() in case the # task is aborted during that time. self.aborted = False self.abortLock = Mutex(recursive=True)
def __init__(self, ui): Thread.__init__(self) self.ui = ui self.dm = self.ui.manager self.lock = Mutex(Qt.QMutex.Recursive) self.stopThread = True self.abortThread = False self.paused = False self._currentTask = None self._systrace = None
def __init__(self): self.pos = np.zeros(3) self.target = None self.speed = None self.velocity = None self._quit = False self.lock = Mutex() self.interval = 30e-3 self.lastUpdate = None self.currentMove = None Thread.__init__(self)
def __init__(self, dev): Thread.__init__(self) self.dev = dev #self.cam = self.dev.getCamera() self.camLock = self.dev.camLock #size = self.cam.getSize() #self.state = {'binning': 1, 'exposure': .001, 'region': [0, 0, size[0]-1, size[1]-1], 'mode': 'No Trigger'} #self.state = self.dev.getParams(['binning', 'exposure', 'region', 'triggerMode']) self.stopThread = False self.lock = Mutex() self.acqBuffer = None #self.frameId = 0 self.bufferTime = 5.0 #self.ringSize = 30 self.tasks = [] ## This thread does not run an event loop, ## so we may need to deliver frames manually to some places self.connections = set() self.connectMutex = Mutex()
def __init__(self, dev): self.dev = dev self.lock = Mutex(recursive=True) self.stopped = False self.interval = 0.3 self.nextMoveId = 0 self.moveRequest = None self._moveStatus = {} Thread.__init__(self)
def __init__(self, dev, startState=None): Thread.__init__(self) self.lock = Mutex(QtCore.QMutex.Recursive) self.dev = dev self.port = self.dev.port if startState is None: self.pos = [0, 0] self.btns = [0, 0] else: self.pos = startState['pos'] self.btns = startState['btns']
def __init__(self, dm, config, name): self.port = config[ 'port'] - 1 ## windows com ports start at COM1, pyserial ports start at 0 self.baud = config.get('baud', 19200) self.driver = Coherent(self.port, self.baud) self.driverLock = Mutex( QtCore.QMutex.Recursive) ## access to low level driver calls self.coherentLock = Mutex( QtCore.QMutex.Recursive) ## access to self.attributes self.coherentPower = 0 self.coherentWavelength = 0 self.mThread = CoherentThread(self, self.driver, self.driverLock) self.mThread.sigPowerChanged.connect(self.powerChanged) self.mThread.sigWavelengthChanged.connect(self.wavelengthChanged) self.mThread.start() Laser.__init__(self, dm, config, name) self.hasShutter = True self.hasTunableWavelength = True
def __init__(self, deviceManager, config, name): QtCore.QObject.__init__(self) # task reservation lock -- this is a recursive lock to allow a task to run its own subtasks # (for example, setting a holding value before exiting a task). # However, under some circumstances we might try to run two concurrent tasks from the same # thread (eg, due to calling processEvents() while waiting for the task to complete). We # don't have a good solution for this problem at present.. self._lock_ = Mutex(QtCore.QMutex.Recursive) self._lock_tb_ = None self.dm = deviceManager self.dm.declareInterface(name, ['device'], self) self._name = name
def __init__(self, dm, config, name): Device.__init__(self, dm, config, name) OptomechDevice.__init__(self, dm, config, name) self.config = config self.configFile = os.path.join('devices', name + '_config.cfg') self.lock = Mutex(QtCore.QMutex.Recursive) self.port = config[ 'port'] ## windows com ports start at COM1, pyserial ports start at 0 # whether this device has an arduino interface protecting it from roe/serial collisions # (see acq4/drivers/SutterMP285/mp285_hack) # If not, then position monitoring is disabled. self.useArduino = config.get('useArduino', False) self.scale = config.pop('scale', (1, 1, 1)) # Interpret "COM1" as port 0 if isinstance(self.port, basestring) and self.port.lower()[:3] == 'com': self.port = int(self.port[3:]) - 1 self.baud = config.get('baud', 9600) ## 9600 is probably factory default self.pos = [0, 0, 0] self.limits = [[[0, False], [0, False]], [[0, False], [0, False]], [[0, False], [0, False]]] self.maxSpeed = 1e-3 self.loadConfig() self.mp285 = SutterMP285Driver(self.port, self.baud) self.driverLock = Mutex(QtCore.QMutex.Recursive) self.mThread = SutterMP285Thread(self, self.mp285, self.driverLock, self.scale, self.limits, self.maxSpeed) self.mThread.sigPositionChanged.connect(self.posChanged) if self.useArduino: self.mThread.start() dm.declareInterface(name, ['stage'], self)
def __init__(self, dm, config, name): Device.__init__(self, dm, config, name) self._DGLock = Mutex( Qt.QMutex.Recursive) ## protects access to _DGHolding, _DGConfig ## Do some sanity checks here on the configuration # 'channels' key is expected; for backward compatibility we just use the top-level config. config = config.get('channels', config) self._DGConfig = config self._DGHolding = {} for ch in config: if config[ch]['type'][0] != 'a' and ('scale' in config[ch] or 'offset' in config[ch]): raise Exception( "Scale/offset only allowed for analog channels. (%s.%s)" % (name, ch)) if 'scale' not in config[ch]: config[ch][ 'scale'] = 1 ## must be int to prevent accidental type conversion on digital data if 'offset' not in config[ch]: config[ch]['offset'] = 0 if config[ch].get('invert', False): if config[ch]['type'][0] != 'd': raise Exception( "Inversion only allowed for digital channels. (%s.%s)" % (name, ch)) config[ch]['scale'] = -1 config[ch]['offset'] = -1 #print "chan %s scale %f" % (ch, config[ch]['scale']) if 'holding' not in config[ch]: config[ch]['holding'] = 0.0 ## It is possible to create virtual channels with no real hardware connection if 'device' not in config[ch]: #print "Assuming channel %s is virtual:" % ch, config[ch] config[ch]['virtual'] = True ## set holding value for all output channels now if config[ch]['type'][1] == 'o': self.setChanHolding(ch, config[ch]['holding']) #self._DGHolding[ch] = config[ch]['holding'] dm.declareInterface(name, ['daqChannelGroup'], self) for ch in config: dm.declareInterface(name + "." + ch, ['daqChannel'], ChannelHandle(self, ch))
def __init__(self, dm, config, name): Device.__init__(self, dm, config, name) OptomechDevice.__init__(self, dm, config, name) self.config = config self.lock = Mutex(QtCore.QMutex.Recursive) self.devGui = None self.lastRunTime = None self.calibrationIndex = None self.targetList = [1.0, {}] ## stores the grids and points used by TaskGui so that they persist self.currentCommand = [0,0] ## The last requested voltage values (but not necessarily the current voltage applied to the mirrors) self.currentVoltage = [0, 0] self.shutterOpen = True ## indicates whether the virtual shutter is closed (the beam is steered to its 'off' position). if 'offVoltage' in config: self.setShutterOpen(False) dm.declareInterface(name, ['scanner'], self)
def __init__(self, dev, driver, driverLock, scale, limits, maxSpd): Thread.__init__(self) self.lock = Mutex(QtCore.QMutex.Recursive) self.scale = scale self.mp285 = driver self.driverLock = driverLock #self.monitor = True self.update = False self.resolution = 'fine' self.dev = dev #self.port = port #self.pos = [0, 0, 0] #self.baud = baud self.velocity = [0, 0, 0] self.limits = deepcopy(limits) self.limitChanged = False self.maxSpeed = maxSpd