def get_axis_setting(axis, setting_name): hash_setting = settings.HashSetting("axis.%s" % axis.name) if len(hash_setting) == 0: # there is no setting value in cache setting_value = get_from_config(axis, setting_name) if setting_value is not None: # write setting to cache hash_setting[setting_name] = setting_value else: setting_value = hash_setting.get(setting_name) if setting_value is None: # take setting value from config setting_value = get_from_config(axis, setting_name) if setting_value is not None: # write setting to cache hash_setting[setting_name] = setting_value try: beacon_channels = axis._beacon_channels except AttributeError: beacon_channels = dict() axis._beacon_channels = beacon_channels try: chan = beacon_channels[setting_name] except KeyError: chan_name = "axis.%s.%s" % (axis.name, setting_name) cb = functools.partial(setting_update_from_channel, setting_name=setting_name, axis=axis) if setting_value is None: chan = channels.Channel(chan_name, callback=cb) else: chan = channels.Channel(chan_name, default_value=setting_value, callback=cb) chan._setting_update_cb = cb beacon_channels[setting_name] = chan else: if setting_value is None: setting_value = chan.value return setting_value
def testExtChannel(self): p1, pipe, queue = test_ext_channel(4, "gerard", "hello") pipe.recv() c = channels.Channel("gerard") p1_output = queue.get() self.assertEquals(c.value, p1_output, 'hello') c.value = 5 gevent.sleep(0.1) p1_output = queue.get() self.assertEquals(p1_output, 5) p1.join()
def __init__(self, config_dict): self.config_dict = config_dict self.config_channel = None try: config_chan_name = "config.%s" % config_dict['name'] except KeyError: # can't have config channel is there is no name pass else: if not 'axes' in config_dict and not 'encoders' in config_dict: # axis config self.config_channel = channels.Channel(config_chan_name, config_dict.to_dict(), callback=self._config_changed)
def testRaiseExceptionInCallback(self): c = channels.Channel("test_exception") exception_raised = {"exc": False} def cbk(value, exception_raised=exception_raised): try: c.value = "bla" except RuntimeError: exception_raised['exc'] = True c.register_callback(cbk) c.value = "tagada" self.assertTrue(exception_raised['exc'])
def testCallback(self): p, pipe, queue = test_ext_channel(2, "bla", "hello") pipe.recv() received_value = {"value": None} cbk_event = gevent.event.Event() def cbk(value, received_value=received_value): cbk_event.set() received_value['value'] = value channels.Channel("bla", callback=cbk) cbk_event.wait(1.) self.assertTrue(received_value['value'] == 'hello') p.join()
def __init__(self, name, config): self.exec_timeout = int(config.get("timeout", 3)) # read_mode 0 means 'first transfocator in beam status is wired first in Wago', # read_mode >0 means 'first transfocator in beam status is wired last in Wago' # the same goes for cmd_mode self.read_mode = int(config.get("read_mode", 0)) self.cmd_mode = int(config.get("cmd_mode", 0)) self.wago_ip = config["controller_ip"] self.wago = None self.empty_jacks = [] self.pinhole = [] self._state_chan = channels.Channel("transfocator:%s" % name, callback=self.__state_changed) if 'lenses' in config: self.nb_lens = int(config["lenses"]) self.nb_pinhole = int(config["pinhole"]) if nb_pinhole == 2: self.nb_pinhole = 2 #pinholes are always the first and the last channels self.pinhole = [0, self.nb_lens-1] elif nb_pinhole == 1 : self.nb_pinhole = 1 #the pinhole is always the first channel self.pinhole = [0] else: #set to zero to avoid ambiguous inputs self.nb_pinhole = 0 else: layout = config['layout'].strip() lenses = [] for i, c in enumerate(layout.split()): if c == 'X': self.empty_jacks.append(i) elif c == 'P': self.pinhole.append(i) elif c == 'L': lenses.append(i) else: raise ValueError("%s: layout: unknown element `%s'" % (name, c)) if len(self.pinhole) > 2: raise ValueError("%s: layout can only have 2 pinholes maximum" % name) self.nb_lens = len(lenses)+len(self.empty_jacks) self.nb_pinhole = len(self.pinhole)
def testTimeout(self): p, pipe, queue = test_ext_channel(3, "test2", "hello") pipe.recv() os.kill(p.pid, signal.SIGSTOP) c = channels.Channel("test2") self.assertEquals(c.timeout, 3) c.timeout = .5 def get_value(c): return c.value t0 = time.time() self.assertRaises(RuntimeError, get_value, c) self.assertTrue(time.time() - t0 >= .5) os.kill(p.pid, signal.SIGCONT) self.assertEquals(c.value, "hello") p.join()
def __init__(self, name, config): self.fshutter_mot = config["fshutter_mot"] self._state_chan = channels.Channel("fshutter:%s" % name, callback=self.__state_changed) try: self.musst = config["musst"] try: self.icepap_steps = config["icepap_steps"] except: self.icepap_steps = 500 except: self.musst = None self.step = config["step"] self.icepap_steps = self.fshutter_mot.steps_per_unit * self.step self.shift = config["shift"] / self.fshutter_mot.steps_per_unit self.enastate = None self.state()
def testSetChannel(self): c = channels.Channel("super mario", "test") self.assertEquals(c.value, 'test')
def testNotInitialized(self): c = channels.Channel("tagada") self.assertEquals(c.value, None)
def _ext_channel(keep_alive_delay, pipe, queue, *args, **kwargs): c = channels.Channel(*args, **kwargs) queue.put(c.value) pipe.send('|') gevent.sleep(keep_alive_delay) queue.put(c.value)
def init(self): self._flux_chan = channels.Channel("mxcube:flux") TangoKeithleyPhotonFlux.init(self)