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)
