189 lines
6.7 KiB
Python
189 lines
6.7 KiB
Python
"""
|
|
PIX_PATHA_CHN = "X04SA-ES3-CCD:PATHa"
|
|
PIX_PATHB_CHN = "X04SA-ES3-CCD:PATHb"
|
|
PIX_FNAM_FMT_CHN = "X04SA-ES3-CCD:FNAM_FMT"
|
|
PIX_FNUM_CHN = "X04SA-ES3-CCD:FNUM"
|
|
PIX_FNAM_CHN = "X04SA-ES3-CCD:FNAM"
|
|
PIX_EXPOSE_CHN = "X04SA-ES3-CCD:EXPOSE"
|
|
PIX_STATUS_CHN = "X04SA-ES3-CCD:STATUS"
|
|
PIX_TRIG_CHN = "X04SA-ES3-CCD:TRIG"
|
|
"""
|
|
|
|
class Pixel(DeviceBase, Readable):
|
|
def __init__(self, name, prefix):
|
|
DeviceBase.__init__(self, name)
|
|
self.prefix = prefix
|
|
self.image_root_folder = "/sls/X04SA/data/x04sa/ES3/pixel/images/"
|
|
|
|
def doInitialize(self):
|
|
self.PIX_TYPE = "PilatusII"
|
|
self.PIX_FILE_HEADER_LENGTH = 0
|
|
self.PIX_COLOR_DEPTH = 32
|
|
self.PIX_XDIM = 487
|
|
self.PIX_YDIM = 195
|
|
self.PIX_THRESH1 = 40
|
|
self.PIX_THRESH2 = 500
|
|
self.PIX_THRESH3 = 8000
|
|
self.PIX_THRESH4 = 100000
|
|
self.PIX_EXP_START_TIME = 0
|
|
self._update_header_length()
|
|
self.show()
|
|
|
|
|
|
def _update_header_length(self):
|
|
format = self.get_image_format()
|
|
ext = format.split('.')[-1]
|
|
if ext == "tif":
|
|
self.IMAGE_HEADER_LENGTH = 4096
|
|
elif ext == "edf":
|
|
self.IMAGE_HEADER_LENGTH = 1024
|
|
else:
|
|
self.IMAGE_HEADER_LENGTH = 0
|
|
|
|
def get_image_filename(self):
|
|
return self.image_root_folder + caget(self.prefix + ":PATHa") + caget(self.prefix + ":PATHb") + caget(self.prefix + ":FNAM")
|
|
|
|
def get_next_image_filename(self):
|
|
return self.image_root_folder + caget(self.prefix + ":PATHa") + caget(self.prefix + ":PATHb") + ( self.get_image_format() % (self.get_count_id()+1))
|
|
|
|
def get_image_format(self):
|
|
return caget(self.prefix + ":FNAM_FMT")
|
|
|
|
def set_image_format(self, fmt):
|
|
caput(self.prefix + ":FNAM_FMT", fmt)
|
|
self._update_header_length();
|
|
|
|
def get_count_id(self):
|
|
return caget (self.prefix + ":FNUM", 'i')
|
|
|
|
def set_count_id(self, val):
|
|
caput (self.prefix + ":FNUM", int(val))
|
|
|
|
def get_expose(self):
|
|
return caget (self.prefix + ":EXPOSE", 'd') / 1000.0
|
|
|
|
def set_expose(self, val):
|
|
val = max(float(val), 0.000005)
|
|
caput (self.prefix + ":EXPOSE", val * 1000)
|
|
|
|
def get_status(self):
|
|
ret = caget (self.prefix + ":STATUS", 's')
|
|
if ret in ["Ready0", "Ready1"]:
|
|
setState(State.Ready)
|
|
elif ret in ["Snapping", "Writing", "Updating"]:
|
|
setState(State.Busy)
|
|
elif ret in ["Error"]:
|
|
setState(State.Error)
|
|
elif ret in ["Time-out", "Disconnected"]:
|
|
setState(State.Offline)
|
|
elif ret in ["Undefined","Connected",]:
|
|
setState(State.Invalid)
|
|
else:
|
|
setState(State.Invalid)
|
|
return ret
|
|
|
|
def is_status_ready(self, status=None):
|
|
if status is None:
|
|
status = self.get_status()
|
|
return status in ["Ready0", "Ready1"]
|
|
|
|
def set_path(self, patha, pathb=""):
|
|
caput(self.prefix + ":PATHa", patha)
|
|
caput(self.prefix + ":PATHb", pathb)
|
|
|
|
|
|
#Trigger Snap Increment Write Inc+Wr Inc+Sn+Wr Connect Disconnect Update
|
|
def set_trigger(self, val):
|
|
caput (self.prefix + ":TRIG", val)
|
|
|
|
def get_trigger(self):
|
|
return caget (self.prefix + ":TRIG")
|
|
|
|
|
|
def get_trigger_id(self):
|
|
return caget (self.prefix + ":TRIG", 'i')
|
|
|
|
def pixsnap(self):
|
|
pixwait() # Wait until pixel detector is ready
|
|
PIX_EXPOSE = epics_get(PIX_EXPOSE_CHN)
|
|
slef.set_trigger ("Inc+Sn+Wr")
|
|
self.PIX_EXP_START_TIME = time.time()
|
|
|
|
|
|
def pixwait(self):
|
|
cnt = 0
|
|
expose = self.get_expose()
|
|
#
|
|
# First wait for "TRIG" to go back to idle. This should
|
|
# ensure that execution of the command has started.
|
|
#
|
|
trig = epics_get (PIX_TRIG_CHN, "long")
|
|
while (get_trigger_id() != 0):
|
|
cnt = cnt + 1
|
|
if (cnt > 1000):
|
|
raise Exception("Trigger signal still busy, pixwait timed-out!\n")
|
|
time.sleep (0.05)
|
|
|
|
#
|
|
# Then wait for exposure time to elapse.
|
|
# (PIX_EXPOSE is in milliseconds!)
|
|
#
|
|
while time.time() <= self.PIX_EXP_START_TIME + (expose * 1000) :
|
|
time.sleep(0.05)
|
|
|
|
#
|
|
# Then wait for the pixel detector to become ready.
|
|
# Wait time is 1000 x 0.05 sec = 50 sec.
|
|
#
|
|
sms_flag = 0
|
|
while (True):
|
|
stat = self.get_status()
|
|
if is_status_ready(stat):
|
|
break
|
|
cnt = cnt + 1
|
|
if cnt > 1000 :
|
|
if (smsFlag == 0):
|
|
print("pixwait: Pixel status did not return to 'Ready' within 50 seconds.")
|
|
notify ("Pixel detector problem in pixwait.")
|
|
sms_flag = 1
|
|
|
|
if stat in ("Undefined", "Time-out", "Error"):
|
|
raise Exception ("Invalid PIX status:", stat)
|
|
time.sleep (0.05)
|
|
|
|
|
|
if sms_flag == 1:
|
|
notify ("Pixel detector seems to have recovered from error.")
|
|
|
|
|
|
|
|
def show(self):
|
|
print ("\nThe current pixel detector settings are:\n")
|
|
if (index (PIX_FILE_FMT, "%") != 0):
|
|
PIX_FNUM = epics_get (PIX_FNUM_CHN)
|
|
printf (" The frame number = %d\n", PIX_FNUM)
|
|
printf (" The file path is: %s\n", PIX_PATH)
|
|
printf (" The file template is: %s\n", PIX_FILE_FMT)
|
|
fnam = epics_get (PIX_FNAM_CHN)
|
|
printf (" The last file name was: %s\n", fnam)
|
|
fnam = sprintf (PIX_FILE_FMT, (PIX_FNUM + 1))
|
|
printf (" The next file name will be: %s\n", fnam)
|
|
else:
|
|
fnam = epics_get (PIX_FNAM_CHN)
|
|
printf (" The last file name was: %s\n", fnam)
|
|
printf (" The next file name will be: %s\n", PIX_FILE_FMT)
|
|
|
|
print(" Exposure time = %5d sec\n" % (self.get_expose(), ))
|
|
print(" Image dimensions: %d x %d pixels (total = %d)\n" % (PIX_XDIM, PIX_YDIM, PIX_XDIM*PIX_YDIM))
|
|
printf(" Threshold values: Thresh1 = %d, Thresh2 = %d, Thresh3 = %d, Thresh4 = %d\n" % (PIX_THRESH1,PIX_THRESH2,PIX_THRESH3,PIX_THRESH4))
|
|
|
|
def doUpdate(self):
|
|
self.get_status()
|
|
|
|
def read(self):
|
|
return None
|
|
|
|
add_device( Pixel("pixel", "X04SA-ES3-CCD"), True)
|
|
pixel.polling = 1000
|
|
pixel.update()
|