def test_group_move(self):
# group creation
mymot1 = get_axis("mymot1")
mymot2 = get_axis("mymot2")
mygrp = Group(mymot1, mymot2)
pos_list = mygrp.position()
pos_list[mymot1] += 0.1
# waits for the end of motions
mygrp.move(pos_list)
self.assertEqual(mygrp.state(), "READY")
def test_group_move(self):
# group creation
mymot1 = get_axis("mymot1")
mymot2= get_axis("mymot2")
mygrp = Group(mymot1, mymot2)
pos_list = mygrp.position()
pos_list[mymot1] += 0.1
# waits for the end of motions
mygrp.move(pos_list)
self.assertEqual(mygrp.state(), "READY")
def test_group_stop(self):
# group creation
mymot1 = get_axis("mymot1")
mymot2 = get_axis("mymot2")
mygrp = Group(mymot1, mymot2)
pos_list = mygrp.position()
pos_list[mymot1] -= 0.1
# non blocking call
mygrp.move(pos_list, wait=False)
# waits for the end of motions
mygrp.stop()
self.assertEqual(mygrp.state(), "READY")
def test_group_stop(self):
# group creation
mymot1 = get_axis("mymot1")
mymot2= get_axis("mymot2")
mygrp = Group(mymot1, mymot2)
pos_list = mygrp.position()
pos_list[mymot1] -= 0.1
# non blocking call
mygrp.move(pos_list, wait=False)
# waits for the end of motions
mygrp.stop()
self.assertEqual(mygrp.state(), "READY")
class CalcController(Controller):
def __init__(self, *args, **kwargs):
Controller.__init__(self, *args, **kwargs)
self._reals_group = None
self._write_settings = False
self._motion_control = False
def initialize(self):
for axis in self.pseudos:
self.get_axis(axis.name)
def _update_refs(self):
Controller._update_refs(self)
self.reals = []
for real_axis in self._tagged['real']:
# check if real axis is really from another controller
if real_axis.controller == self:
raise RuntimeError(
"Real axis '%s` doesn't exist" % real_axis.name)
self.reals.append(real_axis)
event.connect(real_axis, 'position', self._calc_from_real)
event.connect(real_axis, 'state', self._update_state_from_real)
self._reals_group = Group(*self.reals)
event.connect(self._reals_group, 'move_done', self._real_move_done)
self.pseudos = [
axis for axis_name,
axis in self.axes.iteritems() if axis not in self.reals]
def _updated_from_channel(self, setting_name):
#print [axis.settings.get_from_channel(setting_name) for axis in self.reals]
return any([axis.settings.get_from_channel(setting_name) for axis in self.reals])
def _do_calc_from_real(self):
real_positions_by_axis = self._reals_group.position()
real_positions = dict()
for tag, axis_list in self._tagged.iteritems():
if len(axis_list) > 1:
continue
axis = axis_list[0]
if axis in self.reals:
real_positions[tag] = real_positions_by_axis[axis]
return self.calc_from_real(real_positions)
def _calc_from_real(self, *args, **kwargs):
new_positions = self._do_calc_from_real()
for tagged_axis_name, position in new_positions.iteritems():
axis = self._tagged[tagged_axis_name][0]
if axis in self.pseudos:
if self._write_settings and not self._motion_control:
axis.settings.set("_set_position", axis.dial2user(position), write=True)
#print 'calc from real', axis.name, position, self._write_settings
axis.settings.set("dial_position", position, write=self._write_settings)
axis.settings.set("position", axis.dial2user(position), write=False)
else:
raise RuntimeError("cannot assign position to real motor")
def calc_from_real(self, real_positions):
"""Return a dict { pseudo motor tag: new position, ... }"""
raise NotImplementedError
def _update_state_from_real(self, *args, **kwargs):
self._write_settings = not self._updated_from_channel('state')
state = self._reals_group.state()
for axis in self.pseudos:
#print '_update_state_from_real', axis.name, str(state)
axis.settings.set("state", state, write=self._write_settings)
def _real_move_done(self, done):
if done:
#print 'MOVE DONE'
self._motion_control = False
self._write_settings = False
for axis in self.pseudos:
if axis.encoder:
# check position and raise RuntimeError if encoder
# position doesn't correspond to axis position
# (MAXE_E)
axis._do_encoder_reading()
def initialize_axis(self, axis):
if axis in self.pseudos:
self._calc_from_real()
self._update_state_from_real()
def start_one(self, motion):
positions_dict = dict()
axis_tag = None
for tag, axis_list in self._tagged.iteritems():
if len(axis_list) > 1:
continue
x = axis_list[0]
if x in self.pseudos:
if x == motion.axis:
axis_tag = tag
positions_dict[tag] = motion.target_pos
else:
positions_dict[tag] = x._set_position()
move_dict = dict()
for axis_tag, target_pos in self.calc_to_real(axis_tag, positions_dict).iteritems():
real_axis = self._tagged[axis_tag][0]
move_dict[real_axis] = target_pos
self._write_settings = True
self._motion_control = True
# force a global position update in case phys motors never move
self._calc_from_real()
self._reals_group.move(move_dict, wait=False)
def calc_to_real(self, axis_tag, positions_dict):
raise NotImplementedError
def stop(self, axis):
self._reals_group.stop()
def read_position(self, axis):
return axis.settings.get("dial_position")
def state(self, axis, new_state=None):
return self._reals_group.state()
def set_position(self, axis, new_pos):
if not axis in self.pseudos:
raise RuntimeError("Cannot set dial position on motor '%s` from CalcController" % axis.name)
dial_pos = new_pos / axis.steps_per_unit
positions = self._do_calc_from_real()
for tag, axis_list in self._tagged.iteritems():
if len(axis_list) > 1:
continue
if axis in axis_list:
positions[tag]=dial_pos
real_positions = self.calc_to_real(tag, positions)
for real_axis_tag, user_pos in real_positions.iteritems():
self._tagged[real_axis_tag][0].position(user_pos)
break
self._calc_from_real()
return axis.position()
