def msopen(self):
state = self.state()
if state == "CLOSED":
# already closed
return
self._toggle_state()
dispatcher.send("state", self, self.state())
def msclose(self):
state = self.state()
if state == "OPENED":
# already open
return
self._toggle_state()
dispatcher.send("state", self, self.state())
def home(self):
def home_cleanup():
self.fshutter_mot.set_velocity(self.fshutter_mot.velocity(from_config=True))
self.enable(self.icepap_steps)
with cleanup(home_cleanup):
self.disable()
if self.musst:
self.musst.putget("#BTRIG 0")
time.sleep(0.1)
self.fshutter_mot.home(-1)
self.fshutter_mot.dial(0)
self.fshutter_mot.position(0)
self.fshutter_mot.move(self.shift)
self.fshutter_mot.position(0)
self.fshutter_mot.dial(0)
self.fshutter_mot.move(0)
if self.musst:
self.musst.putget("#ABORT")
self.musst.putget("#CH CH1 0")
time.sleep(1)
self.enable()
dispatcher.send("state", self, self.state())
def reading(self):
while self.device.acq_status.lower() == 'running':
dispatcher.send("new_ref", self, { "type":"lima/image", "last_image_acquired":self.device.last_image_acquired })
gevent.sleep(self.parameters['acq_expo_time']/2.0)
# TODO: self.dm.send_new_ref(self, {...}) ? or DataManager.send_new_ref(...) ?
print "end of read_data", self.device.acq_status.lower()
dispatcher.send("new_ref", self, { "type":"lima/image", "last_image_acquired":self.device.last_image_acquired })
def new_data_received(self, event_dict=None, signal=None, sender=None):
channel_data = event_dict.get("channel_data")
if channel_data is None:
return
output_channels_data_dict = self.func(sender, channel_data)
if output_channels_data_dict:
dispatcher.send("new_data", self, {
"channel_data": output_channels_data_dict})
def close(self):
state = self.state()
print "shutter state is %s" % state
if state == "CLOSED":
# already closed
return
self._toggle_state()
new_state = self.state()
dispatcher.send("state", self, new_state)
print "now is %s" % new_state
def open(self):
state = self.state()
print "shutter is %s" % state
if state == "OPENED":
# already open
return
self._toggle_state()
new_state = self.state()
dispatcher.send("state", self, new_state)
print "now is %s" % new_state
def _updateState(self, state, errcode, temperature, dsc, tstamp):
""" Use this to set state whilst profile is running """
if self._profile_task is not None:
with self._lock:
self._state = state
self._errCode = errcode
self._temperature = temperature
self._tstamp = tstamp
self._dscValue = dsc
if tstamp is not None:
self._tstamp = self._tstamp - self._start_tstamp
# self._logger.debug("sending ts, temp, dsc {0},{1},{2}".format(self._tstamp, self._temperature, self._dscValue))
dispatcher.send('linkam_profile_data', self, (tstamp, self._tstamp, self._temperature, self._dscValue))
def emit(self, data):
if not self.reference:
data = self._check_and_reshape(data)
if data.size == 0:
return
self.__description['dtype'] = self.dtype
self.__description['shape'] = self.shape
data_dct = {
"name": self.name,
"description": self.__description,
"data": data,
"channel": self
}
dispatcher.send("new_data", self, data_dct)
def _updateState(self, state, errcode, temperature, dsc, tstamp):
""" Use this to set state whilst profile is running """
if self._profile_task is not None:
with self._lock:
self._state = state
self._errCode = errcode
self._temperature = temperature
self._tstamp = tstamp
self._dscValue = dsc
if tstamp is not None:
self._tstamp = self._tstamp - self._start_tstamp
# self._logger.debug("sending ts, temp, dsc {0},{1},{2}".format(self._tstamp, self._temperature, self._dscValue))
dispatcher.send(
'linkam_profile_data', self,
(tstamp, self._tstamp, self._temperature, self._dscValue))
def _toggle_state(self):
if self.musst:
if not self.enastate:
self.enable(self.icepap_steps)
btrig = self.musst.putget("?BTRIG")
self.musst.putget("#BTRIG %d" % (1 - btrig))
dispatcher.send("state", self, "MOVING")
# 'moving' state is not reported properly
# by libicepap in shutter mode
while True:
fstatus = int(self._icepap_query("?FSTATUS %d\n").split()[-1], 16)
moving = (fstatus & 1 << 10) or (fstatus & 1 << 11)
if moving:
time.sleep(0.01)
else:
break
else:
self._toggle_state_icepap()
def next(self):
self.__sequence_index += 1
gevent.joinall([gevent.spawn(dev_iter.wait_ready) for dev_iter in self._tree.expand_tree()
if dev_iter is not 'root'],
raise_error=True)
try:
if self.__sequence_index:
for dev_iter in self._tree.expand_tree():
if dev_iter is 'root':
continue
dev_iter.next()
except StopIteration: # should we stop all devices?
for acq_dev_iter in (x for x in self._tree.expand_tree() if x is not 'root' and
isinstance(x.device, (AcquisitionDevice, AcquisitionMaster))):
if hasattr(acq_dev_iter, 'wait_reading'):
acq_dev_iter.wait_reading()
dispatcher.send("end", acq_dev_iter.device)
raise
return self
def reading(self):
device = self.device
chid2name = sorted(((nb, name) for name, nb in self.__all_channels.iteritems()))
stop = False
while not stop:
read, write, error = select((self.device,),(), (self.device))
if error:
raise Exception("p201 select error on %s" % error)
if read:
(counters, channels, dma, fifo_half_full, err), tstamp = \
device.acknowledge_interrupt()
if err:
raise Exception("p201 error")
if 12 in counters:
stop = True
if dma:
data, fifo_status = self.device.read_fifo()
#data.shape = -1, len(chanelid2name)
ch_data = {}
for i, (ch_id, ch_name) in enumerate(chid2name):
ch_data[ch_name] = data[:,i]
new_event = {"type": "zerod", "channel_data": ch_data}
dispatcher.send("new_data", self, new_event)
def next(self):
self.__sequence_index += 1
gevent.joinall([
gevent.spawn(dev_iter.wait_ready)
for dev_iter in self._tree.expand_tree() if dev_iter is not 'root'
],
raise_error=True)
try:
if self.__sequence_index:
for dev_iter in self._tree.expand_tree():
if dev_iter is 'root':
continue
dev_iter.next()
except StopIteration: # should we stop all devices?
for acq_dev_iter in (
x for x in self._tree.expand_tree()
if x is not 'root' and isinstance(x.device, (
AcquisitionDevice, AcquisitionMaster))):
if hasattr(acq_dev_iter, 'wait_reading'):
acq_dev_iter.wait_reading()
dispatcher.send("end", acq_dev_iter.device)
raise
return self
def _start(self):
self.start()
self._reading_task = gevent.spawn(self.reading)
dispatcher.send("start", self)
def _run_profile(self, ramps):
currentRamp = 1
abort = '+'
self._start_tstamp = 0.0
try:
state, errcode, temperature, _ = self._getState() # get initial state
if errcode != self.LINKAM_OK:
self._logger.error("Profile received Linkam errcode: {0}".format(self.ErrorToString.get(errCode)))
temperature = -273.15
self._updateState(state,errcode,temperature, 0.0, None)
for (rate, limit, holdTime) in ramps: # get ramp and load it
self._logger.debug("loading rate={0} limit={1} holdtime={2}".format(rate, limit, holdTime))
with self._lock:
self._rampNb = currentRamp
self.rampRate = rate
self.rampLimit = limit
self.rampHoldTime = holdTime
if self._startingRamp == currentRamp:
self._clearBuffer() # empty Linkam buffer ready to collect data
if currentRamp == 1:
dispatcher.send('linkam_profile_start', self)
self.start() # start ramping
state, errcode, temperature, self._start_tstamp = self._getState() # get initial state
if errcode != self.LINKAM_OK:
self._logger.error("Profile received Linkam errcode: {0}".format(self.ErrorToString.get(errCode)))
temperature = -273.15
self._updateState(state,errcode,temperature, 0.0, None)
while (1):
fd, _, _ = gevent.select.select([self._pipe[0]], [], [], 0.1)
if fd:
abort = os.read(self._pipe[0], 1)
break # abort profile
newState, errcode, temperature, tstamp = self._getState()
if errcode != self.LINKAM_OK:
self._logger.error("Profile received Linkam errcode: {0}".format(self.ErrorToString.get(errCode)))
temperature = -273.15
if self._hasDSC:
temperature, dsc, tstamp = self._dscData()
if currentRamp >= self._startingRamp:
if temperature != 32767 and dsc != 32767: # no valid data we're sampling too quickly
self._updateState(newState,errcode,temperature, dsc, tstamp)
else:
self._updateState(newState,errcode,temperature, 0.0, tstamp)
else:
self._updateState(newState,errcode,temperature, 0.0, tstamp)
if newState != state and (newState == self.HOLDINGLIMIT or newState == self.HOLDINGTEMP):
self._logger.debug("changed state to {0}".format(newState))
if holdTime > 0.0:
state = newState;
self._logger.debug("start to do hold for {0}seconds".format(holdTime))
self._hold = True
gevent.spawn(self._run_hold_timer, holdTime)
while(self._hold):
fd, _, _ = gevent.select.select([self._pipe[0]], [], [], 0.1)
if fd:
abort = os.read(self._pipe[0], 1)
break
newState, errcode, temperature, tstamp = self._getState()
if errcode != self.LINKAM_OK:
self._logger.error("Profile received Linkam errcode: {0}".format(self.ErrorToString.get(errCode)))
temperature = -273.15
if self._hasDSC:
if currentRamp >= self._startingRamp:
temperature, dsc, tstamp = self._dscData()
if temperature != 32767 and dsc != 32767: # no valid data we're sampling too quickly
self._updateState(newState,errcode,temperature, dsc, tstamp)
else:
self._updateState(newState,errcode,temperature, 0.0, tstamp)
else:
self._updateState(newState,errcode,temperature, 0.0, tstamp)
self._logger.debug("starting next ramp {0} state {1} newstate {2}".format(currentRamp+1,state,newState))
break # start the next ramp
state = newState
currentRamp += 1
if abort == '|':
break # abort the profile
except:
print "CAUGHT Exception--------------------------------------"
# self._logger.error(self.ErrorToString.get(errCode))
self.rampLimit = self._temperature
finally:
self._logger.debug("doing finally")
self.rampLimit = self._temperature
dispatcher.send('linkam_profile_end', self)
self._profileCompleteCallback()
with self._lock:
self._profile_task = None
def _run_profile(self, ramps):
currentRamp = 1
abort = '+'
self._start_tstamp = 0.0
try:
state, errcode, temperature, _ = self._getState(
) # get initial state
if errcode != self.LINKAM_OK:
self._logger.error(
"Profile received Linkam errcode: {0}".format(
self.ErrorToString.get(errCode)))
temperature = -273.15
self._updateState(state, errcode, temperature, 0.0, None)
for (rate, limit, holdTime) in ramps: # get ramp and load it
self._logger.debug(
"loading rate={0} limit={1} holdtime={2}".format(
rate, limit, holdTime))
with self._lock:
self._rampNb = currentRamp
self.rampRate = rate
self.rampLimit = limit
self.rampHoldTime = holdTime
if self._startingRamp == currentRamp:
self._clearBuffer(
) # empty Linkam buffer ready to collect data
if currentRamp == 1:
dispatcher.send('linkam_profile_start', self)
self.start() # start ramping
state, errcode, temperature, self._start_tstamp = self._getState(
) # get initial state
if errcode != self.LINKAM_OK:
self._logger.error(
"Profile received Linkam errcode: {0}".format(
self.ErrorToString.get(errCode)))
temperature = -273.15
self._updateState(state, errcode, temperature, 0.0, None)
while (1):
fd, _, _ = gevent.select.select([self._pipe[0]], [], [],
0.1)
if fd:
abort = os.read(self._pipe[0], 1)
break # abort profile
newState, errcode, temperature, tstamp = self._getState()
if errcode != self.LINKAM_OK:
self._logger.error(
"Profile received Linkam errcode: {0}".format(
self.ErrorToString.get(errCode)))
temperature = -273.15
if self._hasDSC:
temperature, dsc, tstamp = self._dscData()
if currentRamp >= self._startingRamp:
if temperature != 32767 and dsc != 32767: # no valid data we're sampling too quickly
self._updateState(newState, errcode,
temperature, dsc, tstamp)
else:
self._updateState(newState, errcode, temperature,
0.0, tstamp)
else:
self._updateState(newState, errcode, temperature, 0.0,
tstamp)
if newState != state and (newState == self.HOLDINGLIMIT
or newState == self.HOLDINGTEMP):
self._logger.debug(
"changed state to {0}".format(newState))
if holdTime > 0.0:
state = newState
self._logger.debug(
"start to do hold for {0}seconds".format(
holdTime))
self._hold = True
gevent.spawn(self._run_hold_timer, holdTime)
while (self._hold):
fd, _, _ = gevent.select.select(
[self._pipe[0]], [], [], 0.1)
if fd:
abort = os.read(self._pipe[0], 1)
break
newState, errcode, temperature, tstamp = self._getState(
)
if errcode != self.LINKAM_OK:
self._logger.error(
"Profile received Linkam errcode: {0}".
format(
self.ErrorToString.get(errCode)))
temperature = -273.15
if self._hasDSC:
if currentRamp >= self._startingRamp:
temperature, dsc, tstamp = self._dscData(
)
if temperature != 32767 and dsc != 32767: # no valid data we're sampling too quickly
self._updateState(
newState, errcode, temperature,
dsc, tstamp)
else:
self._updateState(
newState, errcode, temperature,
0.0, tstamp)
else:
self._updateState(newState, errcode,
temperature, 0.0, tstamp)
self._logger.debug(
"starting next ramp {0} state {1} newstate {2}".
format(currentRamp + 1, state, newState))
break # start the next ramp
state = newState
currentRamp += 1
if abort == '|':
break # abort the profile
except:
print "CAUGHT Exception--------------------------------------"
# self._logger.error(self.ErrorToString.get(errCode))
self.rampLimit = self._temperature
finally:
self._logger.debug("doing finally")
self.rampLimit = self._temperature
dispatcher.send('linkam_profile_end', self)
self._profileCompleteCallback()
with self._lock:
self._profile_task = None
def __state_changed(self, st):
dispatcher.send('state', self, st)
def _trigger(self):
self.trigger()
if self._check_ready():
dispatcher.send("start", self)
self._reading_task = gevent.spawn(self.reading)
def _start(self):
self.start()
self._reading_task = gevent.spawn(self.reading)
dispatcher.send("start", self)
def _start(self):
dispatcher.send("start", self)
return_value = self.start()
return return_value
def __state_changed(self, st):
dispatcher.send('state', self, st)
def _start(self):
dispatcher.send("start", self)
return_value = self.start()
return return_value
def _trigger(self):
self.trigger()
if self._check_ready():
dispatcher.send("start", self)
self._reading_task = gevent.spawn(self.reading)
