class Interface(Model):
def __init__(self, serial_number):
self._phidget = InterfaceKit()
self._serial_number = serial_number
self._is_initialized = False
def initialize(self):
if not self._is_initialized:
self._phidget.openPhidget(serial = self._serial_number)
self._phidget.waitForAttach(ATTACH_TIMEOUT)
self._phidget.setRatiometric(False) #note the default is True!
self._is_initialized = True
def identify(self):
if not self._is_initialized:
self.initialize()
name = self._phidget.getDeviceName()
serial_number = self._phidget.getSerialNum()
return "%s, Serial Number: %d" % (name, serial_number)
def read_sensor(self, index):
""" reads the raw value from the sensor at 'index'
returns integer in range [0,4095]
"""
if not self._is_initialized:
self.initialize()
return self._phidget.getSensorRawValue(index)
def read_all_sensors(self):
""" reads all the sensors raw values, indices 0-7
returns list of 8 integers in range [0,4095]
"""
if not self._is_initialized:
self.initialize()
values = []
for i in range(8):
values.append(self.read_sensor(i))
return values
def read_digital_input(self,index):
""" reads the digital input at 'index'
returns True if grounded, False if open (pulled-up to 5V)
"""
if not self._is_initialized:
self.initialize()
return self._phidget.getInputState(index)
def write_digital_output(self,index,state):
if not self._is_initialized:
self.initialize()
return self._phidget.setOutputState(index,state)
def shutdown(self):
if not self._is_initialized:
self.initialize()
self._phidget.closePhidget()
self._is_initialized = False
def __del__(self):
self.shutdown()
class SimplePhidget():
def __init__(self):
try:
self.interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
exit(1)
print("Connecting to Phidget.")
try:
self.interfaceKit.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
exit(1)
print("Connection opened.")
try:
self.interfaceKit.waitForAttach(10000)
except PhidgetException as e:
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
exit(1)
exit(1)
print("Attached to phidget interface.")
def getSensorValue(self, sensor):
return self.interfaceKit.getSensorValue(sensor)
def instanciarIK (self, nroSerie):
"""
Método utilizado para instanciar un objeto de tipo InterfaceKit de la API de Phidgets, que permite interactuar con la placa controladora y sus puertos"""
try:
ik= InterfaceKit()
ik.openRemoteIP(self.__ipWS, self.__puertoWS, nroSerie)
ik.waitForAttach(5000)
return ik
except :
ik.closePhidget()
return None
def setup_interfaceKit():
#Create an interfacekit object
try:
interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
interfaceKit.setOnAttachHandler(inferfaceKitAttached)
interfaceKit.setOnDetachHandler(interfaceKitDetached)
interfaceKit.setOnErrorhandler(interfaceKitError)
interfaceKit.setOnInputChangeHandler(interfaceKitInputChanged)
interfaceKit.setOnOutputChangeHandler(interfaceKitOutputChanged)
interfaceKit.setOnSensorChangeHandler(interfaceKitSensorChanged)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Opening phidget object....")
try:
#interfaceKit.openPhidget()
interfaceKit.openRemoteIP(IP, port=5001)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for attach....")
try:
interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
return interfaceKit
class pumpUSB: # pragma: no cover
def __init__(self):
print ("Initiating pumps")
try:
self.interfaceKit = InterfaceKit()
except RuntimeError as e:
print ("Runtime Exception a: %s" % e.details)
print ("Exiting....")
exit(1)
try:
self.interfaceKit.openPhidget()
except PhidgetException as e:
print ("Phidget Exception b %i: %s" % (e.code, e.details))
print ("Exiting....")
exit(1)
try:
self.interfaceKit.waitForAttach(1000)
except PhidgetException as e:
print ("Phidget Exception c %i: %s" % (e.code, e.details))
raise Exception("Timeout")
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print ("Phidget Exception d %i: %s" % (e.code, e.details))
print ("Exiting....")
exit(1)
self.pumplist = []
for i in range(0, 4):
self.pumplist.append(onePump(self.interfaceKit, i))
print ("Pumps ready")
def getPump(self, index):
return self.pumplist[index]
def getSwitch(self, index):
""" yes it is the same as getPump, standard name use """
return self.pumplist[index]
def close(self):
self.interfaceKit.closePhidget()
def set_bbias(state):
"""Set back bias to state"""
state_dict = {"On" : True,
"Off" : False}
setting = state_dict[state]
## Attach to Phidget controller
relay = InterfaceKit()
relay.openPhidget()
relay.waitForAttach(10000)
## Check if successful
if relay.isAttached():
print "Done!"
else:
print "Failed to connect to Phidget controller"
## Set output to 0 and close
relay.setOutputState(0, setting)
print "BSS is now {0}".format(state)
relay.closePhidget()
return
class Relay(object):
""" Relay class wraps language around the 1014_2 -
PhidgetInterfaceKit 0/0/4 4 relay device. Also works for
SSR relays."""
def __init__(self, in_serial=None):
# http://victorlin.me/posts/2012/08/26/\
# good-logging-practice-in-python
self.log = logging.getLogger(__name__)
if in_serial != None:
# On odroid C1, int conversion raises null byte in argument
# strip out the null byte first
in_serial = in_serial.strip('\0')
self._serial = int(in_serial)
else:
self._serial = None
self.log.debug("Start of phidgeter with serial: %s" % in_serial)
def change_relay(self, relay=0, status=0):
""" Toggle the status of the phidget relay line to low(0) or
high(1) status
"""
self.interface.setOutputState(relay, status)
return 1
def open_phidget(self):
self.log.debug("Attempting to open phidget")
self.interface = InterfaceKit()
if self._serial != None:
self.log.debug("Attempt to open serial: %s" % self._serial)
self.interface.openPhidget(self._serial)
else:
self.log.debug("Attempt to open first found")
self.interface.openPhidget()
wait_interval = 10300
self.log.debug("Wait for attach %sms" % wait_interval)
self.interface.waitForAttach(wait_interval)
self.log.info("Opened phidget")
return 1
def close_phidget(self):
self.log.debug("Attempting to close phidget")
self.interface.closePhidget()
self.log.info("Closed phidget")
return 1
def open_operate_close(self, relay, status):
""" Open the phidget, change the relay to status, close phidget.
"""
self.open_phidget()
result = self.change_relay(relay, status)
self.close_phidget()
return result
def open_toggle_close(self, relay):
""" Find the current status of the specified relay, and set the
status to the opposite.
"""
self.open_phidget()
curr_state = self.interface.getOutputState(relay)
result = self.change_relay(relay, not curr_state)
self.close_phidget()
return result
def zero_on(self):
return self.open_operate_close(relay=0, status=1)
def zero_off(self):
return self.open_operate_close(relay=0, status=0)
def zero_toggle(self):
return self.open_toggle_close(relay=0)
def one_on(self):
return self.open_operate_close(relay=1, status=1)
def one_off(self):
return self.open_operate_close(relay=1, status=0)
def one_toggle(self):
return self.open_toggle_close(relay=1)
def two_on(self):
return self.open_operate_close(relay=2, status=1)
def two_off(self):
return self.open_operate_close(relay=2, status=0)
def two_toggle(self):
return self.open_toggle_close(relay=2)
def three_on(self):
return self.open_operate_close(relay=3, status=1)
def three_off(self):
return self.open_operate_close(relay=3, status=0)
def three_toggle(self):
return self.open_toggle_close(relay=3)
class Relay(object):
""" Relay class wraps language around the 1014_2 -
PhidgetInterfaceKit 0/0/4 4 relay device. Also works for
SSR relays."""
def __init__(self, in_serial=None):
# http://victorlin.me/posts/2012/08/26/\
# good-logging-practice-in-python
self.log = logging.getLogger(__name__)
if in_serial != None:
# On odroid C1, int conversion raises null byte in argument
# strip out the null byte first
in_serial = in_serial.strip('\0')
self._serial = int(in_serial)
else:
self._serial = None
self.log.debug("Start of phidgeter with serial: %s" % in_serial)
def change_relay(self, relay=0, status=0):
""" Toggle the status of the phidget relay line to low(0) or
high(1) status
"""
self.interface.setOutputState(relay, status)
return 1
def open_phidget(self):
self.log.debug("Attempting to open phidget")
self.interface = InterfaceKit()
if self._serial != None:
self.log.debug("Attempt to open serial: %s" % self._serial)
self.interface.openPhidget(self._serial)
else:
self.log.debug("Attempt to open first found")
self.interface.openPhidget()
wait_interval = 10300
self.log.debug("Wait for attach %sms" % wait_interval)
self.interface.waitForAttach(wait_interval)
self.log.info("Opened phidget")
return 1
def close_phidget(self):
self.log.debug("Attempting to close phidget")
self.interface.closePhidget()
self.log.info("Closed phidget")
return 1
def open_operate_close(self, relay, status):
""" Open the phidget, change the relay to status, close phidget.
"""
self.open_phidget()
result = self.change_relay(relay, status)
self.close_phidget()
return result
def open_toggle_close(self, relay):
""" Find the current status of the specified relay, and set the
status to the opposite.
"""
self.open_phidget()
curr_state = self.interface.getOutputState(relay)
result = self.change_relay(relay, not curr_state)
self.close_phidget()
return result
def zero_on(self):
return self.open_operate_close(relay=0, status=1)
def zero_off(self):
return self.open_operate_close(relay=0, status=0)
def zero_toggle(self):
return self.open_toggle_close(relay=0)
def one_on(self):
return self.open_operate_close(relay=1, status=1)
def one_off(self):
return self.open_operate_close(relay=1, status=0)
def one_toggle(self):
return self.open_toggle_close(relay=1)
def two_on(self):
return self.open_operate_close(relay=2, status=1)
def two_off(self):
return self.open_operate_close(relay=2, status=0)
def two_toggle(self):
return self.open_toggle_close(relay=2)
def three_on(self):
return self.open_operate_close(relay=3, status=1)
def three_off(self):
return self.open_operate_close(relay=3, status=0)
def three_toggle(self):
return self.open_toggle_close(relay=3)
class SitwPhidgetsKey(wx.Frame):
def __init__(self, image, parent = None, id = -1,
pos = wx.DefaultPosition, title = sitwPara.Title):
wx.Frame.__init__(self, parent, id, title)
self.SetBackgroundColour((0, 0, 0))
self.SetSize((360, 80))
self.Center()
self.Iconize()
self.panel = wx.Panel(self, size=(320, 336))
self.panel.Bind(wx.EVT_PAINT, self.OnPaint)
#self.panel.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
self.Fit()
self.SampleCount = 12 #for detecting environment 12 x 10sec = 2min
self.KeyPressed = ''
self.CurAction = ''
self.CurPos = win32api.GetCursorPos()
self.PreAction = ''
self.PrePos = win32api.GetCursorPos()
self.bKeyIntervalOK = True
self.KeyMatReady = False
self.ListValMat = []
self.ListValEnv = []
self.ListValBrt = []
self.KeySearch = False
self.dtSearchStart = datetime.datetime.now()
self.dtAction = datetime.datetime.now()
self.dtRefresh = datetime.datetime.now()
self.ChannelCount = 0
self.bNight = False
self.ctEvn = 0
#self.edgeTop = 50
#self.edgeBottom = sitwPara.MoveEdgeBottom1
#self.edgeLeft = 50
#self.edgeRight = 50
self.edgeTop = 18
self.edgeBottom = 18
self.edgeLeft = 18
self.edgeRight = 18
self.strLogAction = ''
self.strLogBrightness = ''
self.subp = None
self.List_ProgramFile = []
self.List_Program = []
self.OnScreenApp = ''
#self.utSchedule = SitwScheduleTools(self)
self.utLogAction = SitwLog(self, 'logAction')
self.utLogBrightness = SitwLog(self, 'logBrightness')
#self.Bind(wx.EVT_SIZE, self.OnResize)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.Bind(wx.EVT_IDLE, self.OnIdle)
self.prtMsg('PhidgetsKey Starting...')
self.readIniFile()
self.initPhidgets()
self.initKeys()
'''collect ambient light info'''
self.timer1 = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.CheckEnv, self.timer1)
self.timer1.Start(sitwPara.SampleInterval_Env) #1000 = 1 second
'''check if there is any key has been covered'''
self.timer2 = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.CheckKey, self.timer2)
self.timer2.Start(sitwPara.SampleInterval_Key) #1000 = 1 second
'''find current on screen experience according to schedule file'''
''' -- removed --'''
'''collect sensor readings for analysis'''
if sitwPara.Log_Brightness == 'Yes':
print '<Log_Brightness On>'
self.timer5 = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.logBrightness, self.timer5)
self.timer5.Start(60 * 1000) #1000 = 1 second
self.utLogBrightness.logMsg('------ log is starting ------\t' + sitwPara.Title)
self.logBrightness(None)
else:
print '<Log_Brightness Off>'
'''collect keypad actions for analysis'''
if sitwPara.Log_Action == 'Yes':
print '<Log_Action On>'
self.timer6 = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.logActions, self.timer6)
self.timer6.Start(9 * 1000) #1000 = 1 second
self.utLogAction.logMsg('------ log is starting ------\t' + sitwPara.Title)
else:
print '<Log_Action Off>'
###Change Cursor
###http://converticon.com/
### http://stackoverflow.com/questions/7921307/temporarily-change-cursor-using-python
self.SetSystemCursor = windll.user32.SetSystemCursor #reference to function
self.SetSystemCursor.restype = c_int #return
self.SetSystemCursor.argtype = [c_int, c_int] #arguments
self.LoadCursorFromFile = windll.user32.LoadCursorFromFileA #reference to function
self.LoadCursorFromFile.restype = c_int #return
self.LoadCursorFromFile.argtype = c_char_p #arguments
CursorPath ='../pic/handr.cur'
NewCursor = self.LoadCursorFromFile(CursorPath)
if NewCursor is None:
print "Error loading the cursor"
elif self.SetSystemCursor(NewCursor, win32con.IDC_ARROW) == 0:
print "Error in setting the cursor"
###Change Cursor
self.DimScreen = wx.DisplaySize()
print 'Screen Dimensions: ' + str(self.DimScreen[0]) + ' x ' + str(self.DimScreen[1])
##########################################
'''m,b parameters for each sensor'''
for i in range(len(sitwPara.List_mb)):
print '===== ', sitwPara.List_mb[i][0], sitwPara.List_mb[i][1]
##########################################
### not in use at the moment
def OnEraseBackground(self, event):
return True
def OnPaint(self, event):
'''
# establish the painting surface
dc = wx.PaintDC(self.panel)
dc.SetPen(wx.Pen('blue', 4))
# draw a blue line (thickness = 4)
dc.DrawLine(50, 20, 300, 20)
dc.SetPen(wx.Pen('red', 1))
# draw a red rounded-rectangle
rect = wx.Rect(50, 50, 100, 100)
dc.DrawRoundedRectangleRect(rect, 8)
# draw a red circle with yellow fill
dc.SetBrush(wx.Brush('yellow'))
x = 250
y = 100
r = 50
dc.DrawCircle(x, y, r)
'''
#dc = wx.PaintDC(self.panel)
dc = wx.BufferedPaintDC(self.panel)
dc.SetBackground(wx.BLUE_BRUSH)
dc.Clear()
self.onDraw(dc)
def onDraw(self, dc):
strColorPen1 = 'red'
strColorPen2 = 'blue'
for i in range(sitwPara.KeyCount):
rect = sitwPara.List_ButtonPos[i]
dc.SetBrush(wx.Brush((0, 255*self.ListValBrt[i], 255*self.ListValBrt[i])))
if self.KeyPressed == sitwPara.List_Action[i]:
dc.SetPen(wx.Pen(strColorPen1, 5))
else:
dc.SetPen(wx.Pen(strColorPen2, 1))
#dc.SetPen(wx.TRANSPARENT_PEN)
dc.DrawRoundedRectangleRect(rect, 8)
def initPhidgets(self):
try:
self.interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
self.interfaceKit.setOnAttachHandler(self.inferfaceKitAttached)
self.interfaceKit.setOnDetachHandler(self.interfaceKitDetached)
self.interfaceKit.setOnErrorhandler(self.interfaceKitError)
self.interfaceKit.setOnInputChangeHandler(self.interfaceKitInputChanged)
self.interfaceKit.setOnOutputChangeHandler(self.interfaceKitOutputChanged)
self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChanged)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Opening phidget object....")
try:
self.interfaceKit.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for attach....")
try:
self.interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
self.closePhidgets()
else:
self.displayDeviceInfo()
#get sensor count
try:
self.ChannelCount = self.interfaceKit.getSensorCount()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
self.closePhidgets()
sitwPara.KeyCount = 0 #no sensor has been detected
self.prtMsg(' ****** No sensor has been detected !!!\n')
print("Setting the data rate for each sensor index to 4ms....")
for i in range(sitwPara.KeyCount):
try:
self.interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
### depends on the low light performance of the sensor
print("Setting the sensitivity for each sensor index to ???....")
for i in range(sitwPara.KeyCount):
try:
self.interfaceKit.setSensorChangeTrigger(i, 2) #~~~~*YL*~~~~
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
def closePhidgets(self):
#print("Press Enter to quit....")
#chr = sys.stdin.read(1)
#print("Closing...")
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
#print("Done.")
#exit(1)
def initKeys(self):
self.KeyPressed = ''
self.ListValMat = []
for i in range(sitwPara.KeyCount):
self.ListValEnv = []
for j in range(self.SampleCount):
self.ListValEnv.append(self.readSensorValue(i))
self.ListValMat.append(self.ListValEnv)
self.KeyMatReady = True
self.ListValBrt = []
for i in range(sitwPara.KeyCount):
self.ListValBrt.append(0)
def readIniFile(self):
self.prtMsg('Read system ini file...')
try:
config = ConfigParser.ConfigParser()
config.readfp(open(sitwPara.FilePath_Ini))
for eachIniData in self.iniData():
Section = eachIniData[0]
Keys = eachIniData[1]
for Key in Keys:
val = config.get(Section, Key)
if (Section == "General"):
if (Key == "KeyCount"):
sitwPara.KeyCount = int(val)
elif (Key == "Sensitivity"):
sitwPara.Sensitivity = float(val)
elif (Key == "MovingPace"):
sitwPara.MovingPace = int(val)
elif (Key == "SampleInterval_Key"):
sitwPara.SampleInterval_Key = int(val)
elif (Key == "SampleInterval_Env"):
sitwPara.SampleInterval_Env = int(val)
elif (Key == "Log_Action"):
sitwPara.Log_Action = str(val)
elif (Key == "Log_Brightness"):
sitwPara.Log_Brightness = str(val)
else:
pass
print('[' + Section + '] ' + Key + ' = ' + val)
continue
except: #IOError
self.prtMsg('Error: readIniFile()')
finally:
pass
def iniData(self):
return (("General",
("KeyCount",
"Sensitivity",
"MovingPace",
"SampleInterval_Key",
"SampleInterval_Env",
"Log_Action",
"Log_Brightness")),)
#Information Display Function
def displayDeviceInfo(self):
print("|------------|----------------------------------|--------------|------------|")
print("|- Attached -|- Type -|- Serial No. -|- Version -|")
print("|------------|----------------------------------|--------------|------------|")
print("|- %8s -|- %30s -|- %10d -|- %8d -|" % (self.interfaceKit.isAttached(), self.interfaceKit.getDeviceName(), self.interfaceKit.getSerialNum(), self.interfaceKit.getDeviceVersion()))
print("|------------|----------------------------------|--------------|------------|")
print("Number of Digital Inputs: %i" % (self.interfaceKit.getInputCount()))
print("Number of Digital Outputs: %i" % (self.interfaceKit.getOutputCount()))
print("Number of Sensor Inputs: %i" % (self.interfaceKit.getSensorCount()))
#Event Handler Callback Functions
def inferfaceKitAttached(self, e):
attached = e.device
print("InterfaceKit %i Attached!" % (attached.getSerialNum()))
def interfaceKitDetached(self, e):
detached = e.device
print("InterfaceKit %i Detached!" % (detached.getSerialNum()))
def interfaceKitError(self, e):
try:
source = e.device
print("InterfaceKit %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
def interfaceKitInputChanged(self, e):
source = e.device
print("InterfaceKit %i: Input %i: %s" % (source.getSerialNum(), e.index, e.state))
def interfaceKitSensorChanged(self, e):
if not self.KeyMatReady:
return
#source = e.device
#print("InterfaceKit %i: Sensor %i: %i" % (source.getSerialNum(), e.index, e.value))
if not self.KeySearch:
self.KeySearch = True
self.dtSearchStart = datetime.datetime.now()
def interfaceKitOutputChanged(self, e):
source = e.device
print("InterfaceKit %i: Output %i: %s" % (source.getSerialNum(), e.index, e.state))
def readSensorValue(self, channel_id):
val = 0.0
try:
val = self.interfaceKit.getSensorValue(channel_id)
#val = self.interfaceKit.getSensorRawValue(channel_id) / 4.095
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
#val = 1.478777 * float(val) + 33.67076 #------ for 1142_0: Lux = m * SensorValue + b
#val = math.exp(0.02385 * float(val) - 0.56905) #------ for 1143_0: Lux = math.exp(m * SensorValue + b)
#val = math.exp(sitwPara.List_mb[channel_id][0] * float(val) + sitwPara.List_mb[channel_id][1]) #------ for 1143_0: Lux = math.exp(m * SensorValue + b)
return val
def CheckEnv(self, event):
for i in range(sitwPara.KeyCount):
ValIns = self.readSensorValue(i)
ValEnv = sum(self.ListValMat[i]) / len(self.ListValMat[i])
if (float(ValIns) / float(ValEnv)) > 0.70 or self.ctEvn >= 2: #natural change or the big change keeps for long time
self.ListValMat[i].pop(0)
self.ListValMat[i].append(ValIns)
self.ctEvn = 0
else:
self.ctEvn += 1 #ignore those suddenly changes
###test
#for val in self.ListValMax:
# print val, '->', sum(val)/len(val)
#print '-------------------------------------------------------'
def CheckKey(self, event):
if not self.KeySearch:
return
dtCurrentTime = datetime.datetime.now()
if dtCurrentTime - self.dtSearchStart > datetime.timedelta(microseconds = 6000000): # =6s ; 1000000 = 1s
self.KeySearch = False
if dtCurrentTime - self.dtAction > datetime.timedelta(microseconds = 500000): # =0.5s ; 1000000 = 1s
self.bKeyIntervalOK = True
else:
self.bKeyIntervalOK = False
self.bNight = True
for i in range(sitwPara.KeyCount):
ValIns = self.readSensorValue(i)
ValEnv = sum(self.ListValMat[i]) / len(self.ListValMat[i])
if ValEnv > 20.0:
self.bNight = False
self.ListValBrt[i] = float(ValIns) / float(ValEnv)
if self.ListValBrt[i] > 1.0:
self.ListValBrt[i] = 1.0
#sort
#self.ListValBrt.sort(cmp = None, key = None, reverse = False)
if self.bNight == False:
NightFactor = 1.0
else:
NightFactor = 1.8
#KeyID = self.ListValBrt.index(min(self.ListValBrt))
for i in range(sitwPara.KeyCount):
KeyID = sitwPara.List_KeyCheckOrder[i]
if self.ListValBrt[KeyID] < (sitwPara.Sensitivity * NightFactor):
bKey = True
break
else:
bKey = False
if bKey == True:
if KeyID == 1:
if self.KeyPressed == 'left' or self.bKeyIntervalOK == True:
self.KeyPressed = 'left'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
elif KeyID == 2:
if self.KeyPressed == 'right' or self.bKeyIntervalOK == True:
self.KeyPressed = 'right'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
elif KeyID == 3:
if self.KeyPressed == 'up' or self.bKeyIntervalOK == True:
self.KeyPressed = 'up'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
elif KeyID == 4:
if self.KeyPressed == 'down' or self.bKeyIntervalOK == True:
self.KeyPressed = 'down'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
elif KeyID == 0:
if self.KeyPressed != 'click' and self.KeyPressed != 'clicked' and self.KeyPressed != 'dclick' and self.KeyPressed != 'dclicked' and self.bKeyIntervalOK == True:
self.KeyPressed = 'click'
self.dtAction = datetime.datetime.now()
elif self.KeyPressed != 'dclick' and self.KeyPressed != 'dclicked' and (dtCurrentTime - self.dtAction > datetime.timedelta(microseconds = 2200000)): # =2.2s ; 1000000 = 1s
self.KeyPressed = 'dclick'
self.dtAction = datetime.datetime.now()
else:
self.KeyPressed = ''
if len(self.KeyPressed) > 0:
###filter
#-- removed ---
###filter
pos = win32api.GetCursorPos()
if self.KeyPressed == 'up':
if pos[1] >= self.edgeTop:
#nx = (pos[0]) * 65535.0 / self.DimScreen[0]
#ny = (pos[1] - sitwPara.MovingPace) * 65535.0 / self.DimScreen[1]
win32api.mouse_event(win32con.MOUSEEVENTF_MOVE, 0, -sitwPara.MovingPace)
#win32api.SetCursorPos((pos[0], pos[1] - sitwPara.MovingPace))
elif self.KeyPressed == 'down':
if pos[1] <= self.DimScreen[1] - self.edgeBottom:
#nx = (pos[0]) * 65535.0 / self.DimScreen[0]
#ny = (pos[1] + sitwPara.MovingPace) * 65535.0 / self.DimScreen[1]
win32api.mouse_event(win32con.MOUSEEVENTF_MOVE, 0, +sitwPara.MovingPace)
#win32api.SetCursorPos((pos[0], pos[1] + sitwPara.MovingPace))
elif self.KeyPressed == 'left':
if pos[0] >= self.edgeLeft:
#nx = (pos[0] - sitwPara.MovingPace) * 65535.0 / self.DimScreen[0]
#ny = (pos[1]) * 65535.0 / self.DimScreen[1]
win32api.mouse_event(win32con.MOUSEEVENTF_MOVE, -sitwPara.MovingPace, 0)
#win32api.SetCursorPos((pos[0] - sitwPara.MovingPace, pos[1]))
elif self.KeyPressed == 'right':
if pos[0] <= self.DimScreen[0] - self.edgeRight:
#nx = (pos[0] + sitwPara.MovingPace) * 65535.0 / self.DimScreen[0]
#ny = (pos[1]) * 65535.0 / self.DimScreen[1]
win32api.mouse_event(win32con.MOUSEEVENTF_MOVE, +sitwPara.MovingPace, 0)
#win32api.SetCursorPos((pos[0] + sitwPara.MovingPace, pos[1]))
elif self.KeyPressed == 'click':
self.click(pos[0], pos[1])
#print '**********click**************'
self.KeyPressed = 'clicked'
elif self.KeyPressed == 'dclick':
self.dclick(pos[0], pos[1])
#print '**********dclick**************'
self.KeyPressed = 'dclicked'
###Action Log
if sitwPara.Log_Action == 'Yes':
self.CurAction = self.KeyPressed
self.CurPos = win32api.GetCursorPos()
if self.CurAction != self.PreAction and len(self.PreAction) > 0:
#dtCurrentTime = datetime.datetime.now()
#strTimeTag = datetime.datetime.strftime(dtCurrentTime, '%Y-%m-%d %H:%M:%S')
#pos = win32api.GetCursorPos()
strLog = self.PreAction + '\t(' + str(self.PrePos[0]) + ',' + str(self.PrePos[1]) + ')' \
+ '\t' + self.OnScreenApp
self.utLogAction.logMsg(strLog)
self.PreAction = self.CurAction
self.PrePos = self.CurPos
def click(self, x,y):
win32api.SetCursorPos((x,y))
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,x,y,0,0)
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,x,y,0,0)
def dclick(self, x,y):
win32api.SetCursorPos((x,y))
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,x,y,0,0)
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,x,y,0,0)
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,x,y,0,0)
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,x,y,0,0)
def logBrightness(self, event):
strValEnv = ''
for i in range(sitwPara.KeyCount):
ValEnv = sum(self.ListValMat[i]) / len(self.ListValMat[i])
strValEnv += str('%06.2f'%(ValEnv)) + '\t'
self.utLogBrightness.logMsg(strValEnv)
self.utLogBrightness.wrtLog(False)
def logActions(self, event):
self.utLogAction.wrtLog(False)
def GetSchedule(self, event):
# --removed --
pass
def FindAppName(self, event):
# --removed --
pass
def prtMsg(self, strMsg):
dtCurrentTime = datetime.datetime.now()
strTimeTag = datetime.datetime.strftime(dtCurrentTime, '%Y-%m-%d %H:%M:%S')
#strTimeTag += str('%03d'%(int(datetime.datetime.strftime(dtCurrentTime, '%f'))/1000))
print(strTimeTag + ' ' + strMsg + "\n")
def OnIdle(self, event):
if not self.KeySearch:
return
dtCurrentTime = datetime.datetime.now()
if dtCurrentTime - self.dtRefresh > datetime.timedelta(microseconds = 200000): #1000000 = 1s
self.dtRefresh = dtCurrentTime
self.panel.Refresh(eraseBackground = False)
pass
def OnCloseWindow(self, event):
print "Do something b4 closing..."
###Change Cursor
CursorPath = "../pic/arrow.cur"
NewCursor = self.LoadCursorFromFile(CursorPath)
if NewCursor is None:
print "Error loading the cursor"
elif self.SetSystemCursor(NewCursor, win32con.IDC_ARROW) == 0:
print "Error in setting the cursor"
###Change Cursor
self.closePhidgets()
self.prtMsg('Destroy Phidgets Key')
if sitwPara.Log_Action == 'Yes':
self.utLogAction.wrtLog(True) #force to log all messages
if sitwPara.Log_Brightness == 'Yes':
self.utLogBrightness.wrtLog(True) #force to log all messages
#time.sleep(1)
self.Destroy()
class Camera(object):
def __init__(self, master, stage, sphere, lakeshore, bk):
self.stop_exposures = False
self.master = master
self.stage = stage
self.sphere = sphere
self.bk = bk
self.lakeshore = lakeshore
self.vbb = 0.0
CfgFile = "/sandbox/lsst/lsst/GUI/UCDavis.cfg"
if self.CheckIfFileExists(CfgFile):
self.CfgFile = CfgFile
else:
print "Configuration file %s not found. Exiting.\n"%CfgFile
sys.exit()
return
self.edtsaodir = eolib.getCfgVal(self.CfgFile,"EDTSAO_DIR")
self.EDTdir = eolib.getCfgVal(self.CfgFile,"EDT_DIR")
self.vendor = eolib.getCfgVal(self.CfgFile,"CCD_MANU").strip()
self.ccd_sern = eolib.getCfgVal(self.CfgFile,"CCD_SERN").strip()
if not (self.vendor == "ITL" or self.vendor == "E2V"):
print "Vendor not recognized. Exiting."
sys.exit()
self.fitsfilename = "dummy.fits" # Just a dummy - not really used
self.relay = InterfaceKit()
return
def GetVoltageLookup(self):
self.vbb = 0.0
try:
self.voltage_lookup = [ # Lookup table with voltage values
{"Name":"VCLK_LO", "Value": float(eolib.getCfgVal(self.CfgFile,"VCLK_LO")), "Vmin": 0.0, "Vmax": 10.0, "chan":["a0188"]},
{"Name":"VCLK_HI", "Value": float(eolib.getCfgVal(self.CfgFile,"VCLK_HI")), "Vmin": 0.0, "Vmax": 10.0, "chan":["a0080"]},
{"Name":"VV4", "Value": float(eolib.getCfgVal(self.CfgFile,"VV4")), "Vmin": -5.0, "Vmax": 5.0, "chan":["a0280"]},
{"Name":"VDD", "Value": float(eolib.getCfgVal(self.CfgFile,"VDD")), "Vmin": 0.0, "Vmax": 30.0, "chan":["a0380"]},
{"Name":"VRD", "Value": float(eolib.getCfgVal(self.CfgFile,"VRD")), "Vmin": 0.0, "Vmax": 20.0, "chan":["a0384"]},
{"Name":"VOD", "Value": float(eolib.getCfgVal(self.CfgFile,"VOD")), "Vmin": 0.0, "Vmax": 30.0, "chan":["a0388","a038c"]},
{"Name":"VOG", "Value": float(eolib.getCfgVal(self.CfgFile,"VOG")), "Vmin": -5.0, "Vmax": 5.0, "chan":["a0288","a028c"]},
{"Name":"PAR_CLK_LO", "Value": float(eolib.getCfgVal(self.CfgFile,"PAR_CLK_LO")), "Vmin":-10.0, "Vmax": 0.0, "chan":["a0184"]},
{"Name":"PAR_CLK_HI", "Value": float(eolib.getCfgVal(self.CfgFile,"PAR_CLK_HI")), "Vmin": 0.0, "Vmax": 10.0, "chan":["a0084"]},
{"Name":"SER_CLK_LO", "Value": float(eolib.getCfgVal(self.CfgFile,"SER_CLK_LO")), "Vmin":-10.0, "Vmax": 0.0, "chan":["a0180"]},
{"Name":"SER_CLK_HI", "Value": float(eolib.getCfgVal(self.CfgFile,"SER_CLK_HI")), "Vmin": 0.0, "Vmax": 10.0, "chan":["a008c"]},
{"Name":"RG_LO", "Value": float(eolib.getCfgVal(self.CfgFile,"RG_LO")), "Vmin":-10.0, "Vmax": 0.0, "chan":["a018c"]},
{"Name":"RG_HI", "Value": float(eolib.getCfgVal(self.CfgFile,"RG_HI")), "Vmin": 0.0, "Vmax": 10.0, "chan":["a0088"]}]
self.vbb = float(eolib.getCfgVal(self.CfgFile,"BSS_TEST"))
except Exception as e:
print "Voltage lookup routine failed! Exception of type %s and args = \n"%type(e).__name__, e.args
return
def GetOffsetLookup(self):
try:
self.offset_lookup = [ # Lookup table with channel offsets
{"Segment":1, "Channel":1, "chan":"3008", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_1"))},
{"Segment":2, "Channel":5, "chan":"3108", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_2"))},
{"Segment":3, "Channel":2, "chan":"3018", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_3"))},
{"Segment":4, "Channel":6, "chan":"3118", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_4"))},
{"Segment":5, "Channel":3, "chan":"3028", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_5"))},
{"Segment":6, "Channel":7, "chan":"3128", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_6"))},
{"Segment":7, "Channel":4, "chan":"3038", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_7"))},
{"Segment":8, "Channel":8, "chan":"3138", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_8"))},
{"Segment":9, "Channel":9, "chan":"3208", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_9"))},
{"Segment":10, "Channel":13, "chan":"3308", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_10"))},
{"Segment":11, "Channel":10, "chan":"3218", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_11"))},
{"Segment":12, "Channel":14, "chan":"3318", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_12"))},
{"Segment":13, "Channel":11, "chan":"3228", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_13"))},
{"Segment":14, "Channel":15, "chan":"3328", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_14"))},
{"Segment":15, "Channel":12, "chan":"3238", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_15"))},
{"Segment":16, "Channel":16, "chan":"3338", "offset":int(eolib.getCfgVal(self.CfgFile,"OFF_SEG_16"))}]
except Exception as e:
print "Secment offset lookup routine failed! Exception of type %s and args = \n"%type(e).__name__, e.args
self.master.update()
return
def CheckIfFileExists(self, filename):
try:
FileSize = os.path.getsize(filename)
return True
except OSError:
return False
def Initialize_BSS_Relay(self):
print('Connecting to BSS controller...')
self.relay.openPhidget(403840) # Serial number 403840 is the Vbb control Phidgets relay
self.relay.waitForAttach(10000)
if (self.relay.isAttached() and self.relay.getSerialNum() == 403840):
# Serial number checks to make sure we have the right Phidgets
print "Successfully initialized BSS Relay\n"
self.master.update()
self.bss_relay_status = True
else:
print "Failed to initialize BSS relay\n"
self.master.update()
self.bss_relay_status = False
self.relay.closePhidget()
return
def Close_BSS_Relay(self):
print('Closing BSS relay connection...')
self.relay.closePhidget()
return
def Check_Communications(self):
"""Checks on communications status with the camera, called by the communications frame/class"""
self.comm_status = False
(stdoutdata, stderrdata) = self.runcmd([self.edtsaodir+"/fclr"])
if stdoutdata.split()[1] == 'done' and stderrdata == '':
self.comm_status = True
self.bss_relay_status = False
self.relay.openPhidget(403840) # Serial number 403840 is the Vbb control Phidgets relay
self.relay.waitForAttach(10000)
if (self.relay.isAttached() and self.relay.getSerialNum() == 403840):
self.bss_relay_status = True
self.relay.closePhidget()
return
def Dummy(self):
# Dummy operation for testing
return
def Expose(self):
#Calls exp_acq script or dark_acq script, depending on exposure type.
now = datetime.datetime.now()
timestamp = "%4d%02d%02d%02d%02d%02d"%(now.year,now.month,now.day,now.hour,now.minute,now.second)
sensor_id = self.sensor_id_ent.get()
exptime = self.time_ent.get()
test_type = self.test_type.get()
image_type = self.image_type.get()
mask_type = self.mask_type.get()
sequence_num = self.sequence_num_ent.get()
filter=self.filter.get()
self.fitsfilename = ("testdata/"+sensor_id+"_"+test_type+"_"+image_type+"_%03d_"+timestamp+".fits")%(int(sequence_num))
print "Filename:%s\n"%self.fitsfilename
self.master.update()
if image_type == 'light':
self.exp_acq(exptime=exptime, fitsfilename=self.fitsfilename)
elif image_type == 'flat':
self.exp_acq(exptime=exptime, fitsfilename=self.fitsfilename)
elif image_type == 'spot':
self.exp_acq(exptime=exptime, fitsfilename=self.fitsfilename)
elif image_type == 'dark':
self.dark_acq(exptime=exptime, fitsfilename=self.fitsfilename)
elif image_type == 'bias':
# A bias exposure is just a dark exposure with 0 time.
self.dark_acq(exptime=0.0, fitsfilename=self.fitsfilename)
else:
print "Image type not recogized. Exposure not done."
return
try:
self.sphere.Read_Photodiode()
mondiode = self.sphere.diode_current
srcpwr = self.sphere.light_intensity
self.lakeshore.Read_Temp()
self.stage.Read_Encoders()
# Add other things here(temp, etc. when they are available)
ucdavis2lsst.fix(self.fitsfilename, self.CfgFile, sensor_id, mask_type, test_type, image_type, sequence_num, exptime, filter, srcpwr, mondiode, \
self.lakeshore.Temp_A, self.lakeshore.Temp_B, self.lakeshore.Temp_Set, stage_pos = self.stage.read_pos)
except Exception as e:
print "Fits file correction failed! Exception of type %s and args = \n"%type(e).__name__, e.args
print "File %s is not LSST compliant"%self.fitsfilename
return
def MultiExpose(self):
#Launches a series of exposures
numinc = int(self.numinc_ent.get())
start_sequence_num = int(self.start_sequence_num_ent.get())
num_per_increment = int(self.numperinc_ent.get())
dither_radius = int(self.dither_radius_ent.get())
if num_per_increment < 1 or num_per_increment > 1000:
print "Number of exposures per increment must be an integer between 1 and 1000. Exposures not done."
self.master.update()
return
increment_type = self.increment_type.get()
increment_value = self.increment_value_ent.get()
delay_value = float(self.delay_ent.get())
print "Multiple Exposures will start in %.1f seconds. Number of Increments = %d, NumPerInc = %d, StartNum = %d, Type = %s, Increment Value = %s"%(delay_value,numinc,num_per_increment,start_sequence_num,increment_type, increment_value)
self.master.update()
time.sleep(delay_value) # Delay to allow you to turn off the lights
if increment_type == "None":
for exposure_counter in range(numinc):
for sub_counter in range(num_per_increment):
seq_num = start_sequence_num + num_per_increment * exposure_counter + sub_counter
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
else:
self.Expose()
elif increment_type == "X":
for exposure_counter in range(numinc):
self.stage.Read_Encoders()
self.stage.GUI_Write_Encoder_Values()
for sub_counter in range(num_per_increment):
seq_num = start_sequence_num + num_per_increment * exposure_counter + sub_counter
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
else:
self.Expose()
self.stage.set_pos = [int(increment_value), 0, 0]
self.stage.Move_Stage()
elif increment_type == "Y":
for exposure_counter in range(numinc):
self.stage.Read_Encoders()
self.stage.GUI_Write_Encoder_Values()
for sub_counter in range(num_per_increment):
seq_num = start_sequence_num + num_per_increment * exposure_counter + sub_counter
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
self.Expose()
self.stage.set_pos = [0, int(increment_value), 0]
self.stage.Move_Stage()
elif increment_type == "Z":
for exposure_counter in range(numinc):
self.stage.Read_Encoders()
self.stage.GUI_Write_Encoder_Values()
for sub_counter in range(num_per_increment):
seq_num = start_sequence_num + num_per_increment * exposure_counter + sub_counter
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
else:
self.Expose()
self.stage.set_pos = [0, 0, int(increment_value)]
self.stage.Move_Stage()
elif increment_type == "Exp(Log)":
for exposure_counter in range(numinc):
for sub_counter in range(num_per_increment):
seq_num = start_sequence_num + num_per_increment * exposure_counter + sub_counter
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
exptime = self.time_ent.get()
if dither_radius > 0 and num_per_increment > 1:
#x_dither = int(dither_radius * (-1.0 + 2.0 * numpy.random.rand()))
#y_dither = int(dither_radius * (-1.0 + 2.0 * numpy.random.rand()))
#self.stage.set_pos = [x_dither, y_dither, 0]
x_dither = int(dither_radius)
y_dither = 0.0
self.stage.set_pos = [x_dither, y_dither, 0]
self.stage.Move_Stage()
self.stage.Read_Encoders()
self.stage.GUI_Write_Encoder_Values()
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
else:
self.Expose()
# Exposure time increments in log steps
self.time_ent.delete(0,END)
self.time_ent.insert(0,str(float(increment_value) * float(exptime)))
elif increment_type == "Exp(Linear)":
for exposure_counter in range(numinc):
for sub_counter in range(num_per_increment):
seq_num = start_sequence_num + num_per_increment * exposure_counter + sub_counter
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
exptime = self.time_ent.get()
if dither_radius > 0 and num_per_increment > 1:
#x_dither = int(dither_radius * (-1.0 + 2.0 * numpy.random.rand()))
#y_dither = int(dither_radius * (-1.0 + 2.0 * numpy.random.rand()))
#self.stage.set_pos = [x_dither, y_dither, 0]
x_dither = int(dither_radius)
y_dither = 0.0
self.stage.set_pos = [x_dither, y_dither, 0]
self.stage.Move_Stage()
self.stage.Read_Encoders()
self.stage.GUI_Write_Encoder_Values()
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
else:
self.Expose()
# Exposure time increments in linear steps
self.time_ent.delete(0,END)
self.time_ent.insert(0,str(float(increment_value) + float(exptime)))
elif increment_type == "Cooling Curve":
Starting_Temp = 20.0
Final_Temp = -100.0
Target_Temps = numpy.linspace(Starting_Temp, Final_Temp, numinc)
self.lakeshore.Read_Temp()
for exposure_counter in range(numinc):
Target_Temp = Target_Temps[exposure_counter]
# Wait until it cools to the target level
while self.lakeshore.Temp_B > Target_Temp:
self.master.update()
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
self.lakeshore.Read_Temp()
time.sleep(5.0)
# First take num_per_increment - 1 bias frames, then 1 dark
for sub_counter in range(num_per_increment - 1):
seq_num = start_sequence_num + num_per_increment * exposure_counter + sub_counter
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
self.image_type.set("bias")
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
else:
self.Expose()
seq_num = start_sequence_num + num_per_increment * exposure_counter + num_per_increment - 1
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
self.image_type.set("dark")
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
else:
self.Expose()
elif increment_type == "Light Intensity":
for exposure_counter in range(numinc):
self.sphere.light_intensity=float(self.sphere.light_intensity_ent.get())
self.sphere.VA_Set_Light_Intensity(self.sphere.light_intensity)
time.sleep(10)
self.sphere.Read_Photodiode()
for sub_counter in range(num_per_increment):
seq_num = start_sequence_num + num_per_increment * exposure_counter + sub_counter
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
if dither_radius > 0 and num_per_increment > 1:
x_dither = int(dither_radius * (-1.0 + 2.0 * numpy.random.rand()))
y_dither = int(dither_radius * (-1.0 + 2.0 * numpy.random.rand()))
self.stage.set_pos = [x_dither, y_dither, 0]
self.stage.Move_Stage()
self.stage.Read_Encoders()
self.stage.GUI_Write_Encoder_Values()
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
else:
self.Expose()
# Change light intensity of sphere with increment
new_intensity = self.sphere.light_intensity + float(increment_value)
if new_intensity < 0.0 or new_intensity > 100.0:
print "Intensity outside of limits. Quitting exposures."
self.master.update()
return
self.sphere.light_intensity_ent.delete(0,END)
self.sphere.light_intensity_ent.insert(0,str(new_intensity))
# Makes focus curves, at increasing intensities if desired.
###!!!! Assumes stages have been zeroed at location of focus curve minimum!!!!
### Backlash distance ~35 steps ###
elif increment_type == "V-curve (Linear)":
for exposure_counter in range(numinc):
self.stage.Read_Encoders() # read encoders to get current pos (should be zero, but if it isn't, ok)
print "Current pos:" +str(self.stage.read_pos)
zpos_cur=self.stage.read_pos[2]/2.5 # divide microns by 2.5 to get steps
zmov_dist=-zpos_cur-dither_radius-45 # move stage back by the dither radius, plus some distance to account for backlash to overshoot
self.stage.set_pos = [0,0,zmov_dist] # prepare move constant list
print "Moving in z: "+str(zmov_dist)
self.stage.Move_Stage() # move
self.stage.Read_Encoders() # read
print "Current pos:" +str(self.stage.read_pos)
zpos_cur=self.stage.read_pos[2]/2.5 # divide by 2.5 to get steps
zmov_dist=numpy.abs(zpos_cur+dither_radius) + 36 # move the stage forward by the difference between cur. pos. and (neg)dither radius, plus calc. backlash
self.stage.set_pos = [0,0,zmov_dist] # prepare move constant list
print "Moving in z: "+str(zmov_dist)
self.stage.Move_Stage() # move
self.stage.Read_Encoders()
self.stage.GUI_Write_Encoder_Values()
print "Current pos:" +str(self.stage.read_pos)
self.master.update()
for sub_counter in range(num_per_increment):
seq_num = start_sequence_num + num_per_increment * exposure_counter + sub_counter
self.sequence_num_ent.delete(0,END)
self.sequence_num_ent.insert(0,"%03d"%seq_num)
exptime = self.time_ent.get()
if dither_radius > 0 and num_per_increment > 1:
self.stage.Read_Encoders()
zpos_cur=self.stage.read_pos[2]/2.5
ndithers_left=num_per_increment-sub_counter # the number of exposures left to reach other end of dither radius
x_dither = int(dither_radius/4. * (-1.0 + 2.0 * numpy.random.rand()))
y_dither = int(dither_radius/4. * (-1.0 + 2.0 * numpy.random.rand()))
z_dither = int(numpy.ceil(numpy.abs(zpos_cur-dither_radius)/ndithers_left)) #round up so that it never rounds down
foo_dithers=[x_dither,y_dither,z_dither]
self.stage.Read_Encoders()
for i in range(3):
thepos=self.stage.read_pos[i]/2.5
if abs(thepos-foo_dithers[i])>1.2*dither_radius:
print "Dither radius exceeded, moving back stage #"+str(i)
if i==3: foo_dithers[i]=int(-1.*thepos + numpy.sign(thepos)*35) # purposeful movement of z-stage back by offset from zero + backlash
else: foo_dithers[i]=int(-1.*thepos)
print "Position: " +str(thepos)+", Requested move: "+str(foo_dithers[i])
self.master.update()
self.stage.set_pos = foo_dithers
self.stage.Move_Stage()
self.stage.Read_Encoders()
self.stage.GUI_Write_Encoder_Values()
if self.stop_exposures:
print "Stopping Exposures based on user input"
self.master.update()
self.stop_exposures = False
return
else:
self.Expose()
# return the stage to zero
self.stage.Read_Encoders() # read encoders to get current pos (should be zero, but if it isn't, ok)
zpos_cur=self.stage.read_pos[2]/2.5 # divide microns by 2.5 to get steps
zmov_dist=-zpos_cur-35 # move stage back by the dither radius, plus some distance to account for backlash to overshoot
self.stage.set_pos = [0,0,zmov_dist] # prepare move constant list
self.stage.Move_Stage() # move
self.stage.Read_Encoders()
self.stage.GUI_Write_Encoder_Values()
# Exposure time increments in linear steps
self.time_ent.delete(0,END)
self.time_ent.insert(0,str(float(increment_value) + float(exptime)))
else:
print "No Increment Type found\n"
self.master.update()
return
return
def StopExposures(self):
self.stop_exposures = True
return
def Define_Frame(self):
""" Camera control frame, definitions for buttons and labels in the GUI """
self.frame=Frame(self.master, relief=GROOVE, bd=4)
self.frame.grid(row=2,column=0,rowspan=2,columnspan=4)
frame_title = Label(self.frame,text="Camera Control",relief=RAISED,bd=2,width=24, bg="light yellow",font=("Times", 16))
frame_title.grid(row=0, column=1)
setup_but = Button(self.frame, text="CCD Setup", width=16,command=self.ccd_setup)
setup_but.grid(row=0,column=2)
off_but = Button(self.frame, text="CCD Off", width=16,command=self.ccd_off)
off_but.grid(row=0,column=3)
bias_but_on = Button(self.frame, text="BackBias On", width=12,command=self.bbias_on_button)
bias_but_on.grid(row=1,column=2)
self.bbias_on_confirm_ent = Entry(self.frame, justify="center", width=12)
self.bbias_on_confirm_ent.grid(row=2,column=2)
self.bbias_on_confirm_ent.focus_set()
bbias_on_confirm_title = Label(self.frame,text="BackBias On Confirm",relief=RAISED,bd=2,width=16)
bbias_on_confirm_title.grid(row=3, column=2)
bias_but_off = Button(self.frame, text="Back Bias Off", width=12,command=self.bbias_off)
bias_but_off.grid(row=1,column=3)
self.filter = StringVar()
self.filter.set("r")
filter_type = OptionMenu(self.frame, self.filter, "u", "g", "r", "i", "z", "y")
filter_type.grid(row=0, column = 0)
filter_title = Label(self.frame,text="FILTER",relief=RAISED,bd=2,width=12)
filter_title.grid(row=1, column=0)
self.mask_type = StringVar()
self.mask_type.set("none")
mask_type = OptionMenu(self.frame, self.mask_type, "none", "40k-spots-30um", "40k-spots-3um", "spot-2um", "spot-5um", "spot-100um", "spot-200um", "target")
mask_type.grid(row=2, column = 0)
mask_type_title = Label(self.frame,text="Mask Type",relief=RAISED,bd=2,width=12)
mask_type_title.grid(row=3, column=0)
self.sensor_id_ent = Entry(self.frame, justify="center", width=12)
self.sensor_id_ent.grid(row=4,column=0)
self.sensor_id_ent.focus_set()
self.sensor_id_ent.insert(0,self.ccd_sern)
sensor_id_title = Label(self.frame,text="Sensor_ID",relief=RAISED,bd=2,width=16)
sensor_id_title.grid(row=5, column=0)
self.test_type = StringVar()
self.test_type.set("dark")
test_type = OptionMenu(self.frame, self.test_type, "dark", "flat", "spot")
test_type.grid(row=2, column = 1)
test_type_title = Label(self.frame,text="Test Type",relief=RAISED,bd=2,width=12)
test_type_title.grid(row=3, column=1)
self.image_type = StringVar()
self.image_type.set("dark")
image_type = OptionMenu(self.frame, self.image_type, "dark", "flat", "bias", "spot")
image_type.grid(row=4, column = 1)
image_type_title = Label(self.frame,text="Image Type",relief=RAISED,bd=2,width=12)
image_type_title.grid(row=5, column=1)
self.time_ent = Entry(self.frame, justify="center", width=12)
self.time_ent.grid(row=3,column=3)
self.time_ent.focus_set()
self.time_ent.insert(0,'0')
time_title = Label(self.frame,text="Exposure Time",relief=RAISED,bd=2,width=24)
time_title.grid(row=4, column=3)
self.sequence_num_ent = Entry(self.frame, justify="center", width=12)
self.sequence_num_ent.grid(row=3,column=4)
self.sequence_num_ent.focus_set()
self.sequence_num_ent.insert(0,'001')
sequence_num_title = Label(self.frame,text="Sequence Number",relief=RAISED,bd=2,width=24)
sequence_num_title.grid(row=4, column=4)
capture_but = Button(self.frame, text="Expose", width=24,command=self.Expose)
capture_but.grid(row=0,column=4)
# Multiple exposure sub frame:
multi_exp_title = Label(self.frame,text="Multi Exposure Control",relief=RAISED,bd=2,width=24, bg="light yellow",font=("Times", 16))
multi_exp_title.grid(row=6, column=0)
self.numinc_ent = Entry(self.frame, justify="center", width=12)
self.numinc_ent.grid(row=7,column=0)
self.numinc_ent.focus_set()
numinc_title = Label(self.frame,text="# of Increments",relief=RAISED,bd=2,width=16)
numinc_title.grid(row=8, column=0)
self.numperinc_ent = Entry(self.frame, justify="center", width=12)
self.numperinc_ent.grid(row=9,column=0)
self.numperinc_ent.focus_set()
self.numperinc_ent.insert(0,'1')
num_per_increment_title = Label(self.frame,text="# Per Increment",relief=RAISED,bd=2,width=16)
num_per_increment_title.grid(row=10, column=0)
self.start_sequence_num_ent = Entry(self.frame, justify="center", width=12)
self.start_sequence_num_ent.grid(row=7,column=1)
self.start_sequence_num_ent.focus_set()
self.start_sequence_num_ent.insert(0,'001')
start_sequence_num_title = Label(self.frame,text="Starting Seq Num",relief=RAISED,bd=2,width=16)
start_sequence_num_title.grid(row=8, column=1)
self.dither_radius_ent = Entry(self.frame, justify="center", width=12)
self.dither_radius_ent.grid(row=9,column=1)
self.dither_radius_ent.focus_set()
self.dither_radius_ent.insert(0,'0')
dither_radius_title = Label(self.frame,text="Dither Radius (steps)",relief=RAISED,bd=2,width=24)
dither_radius_title.grid(row=10, column=1)
self.increment_type = StringVar()
self.increment_type.set("None")
self.increment_type = StringVar()
self.increment_type.set("")
increment_type = OptionMenu(self.frame, self.increment_type, "None", "X", "Y", "Z", "Exp(Log)", "Exp(Linear)", "V-curve (Linear)", "Light Intensity", "Cooling Curve")
increment_type.grid(row=7, column = 2)
increment_type_title = Label(self.frame,text="Increment Type",relief=RAISED,bd=2,width=12)
increment_type_title.grid(row=8, column=2)
self.increment_value_ent = Entry(self.frame, justify="center", width=12)
self.increment_value_ent.grid(row=7,column=3)
self.increment_value_ent.focus_set()
self.increment_value_ent.insert(0,'0')
increment_value_title = Label(self.frame,text="Increment",relief=RAISED,bd=2,width=12)
increment_value_title.grid(row=8, column=3)
stop_exposures_but = Button(self.frame, text="Stop Exposures", width=16,command=self.StopExposures)
stop_exposures_but.grid(row=10,column=3)
multi_capture_but = Button(self.frame, text="Start Exposures\nNumber of Exposures = \n # of Increments * # Per Increment", width=26,command=self.MultiExpose)
multi_capture_but.grid(row=7,column=4)
self.delay_ent = Entry(self.frame, justify="center", width=12)
self.delay_ent.grid(row=9,column=4)
self.delay_ent.focus_set()
self.delay_ent.insert(0,'0')
delay_title = Label(self.frame,text="Delay Before Start(sec)",relief=RAISED,bd=2,width=26)
delay_title.grid(row=10, column=4)
return
def runcmd(self, args,env=None,verbose=0):
# runcmd is used to make external calls, where args is a list of what would be space separated arguments,
# with the convention that args[0] is the name of the command.
# An argument of space separated names should not be quoted
# Otherwise, this command receives stdout and stderr back through a pipe and returns it.
# On error, this program will throw
# StandardError with a string containing the stderr return from the calling program.
# Throws may also occur directly from
# process.POpen (e.g., OSError. This program will also return a cmd style
# facsimile of the command and arguments.
cmdstring = args[0]
for i in range(1,len(args)):
if args[i].find(' ') >= 0: cmdstring += " '%s'" % args[i]
else: cmdstring += " %s" % args[i]
errcode = 0
#print "In runcmd. Running the following command:%s \n"%cmdstring
# Call the requested command, wait for its return,
# then get any return pipe output
proc = subprocess.Popen(args,stdout=subprocess.PIPE,stderr=subprocess.PIPE,close_fds=False,env=env)
errcode = proc.wait()
(stdoutdata, stderrdata) = proc.communicate()
if stdoutdata.find(' ') >= 0:
sys.stdout.write(stdoutdata)
if stderrdata.find(' ') >= 0:
sys.stderr.write(stderrdata)
# The calling program will not throw on failure,
# but we should to make it compatible with
# Python programming practices
if errcode:
errstring = 'Command "%s" failed with code %d\n------\n%s\n' % (cmdstring,errcode,stderrdata)
raise StandardError(errstring)
return (stdoutdata, stderrdata)
def bbias_on(self):
"""Python version of the bbias_on script"""
print('Connecting to BSS controller...')
# First set the voltage on the BK and turn the output on
self.bk.Set_Voltage(-self.vbb) # Note minus sign!
self.bk.bbias_on()
time.sleep(0.5)
if self.bss_relay_status:
self.relay.openPhidget(403840) # Serial number 403840 is the Vbb control Phidgets relay
self.relay.waitForAttach(10000)
if (self.relay.isAttached() and self.relay.getSerialNum() == 403840):
self.relay.setOutputState(0,True)
print('BSS is now ON')
print('Done!')
self.master.update()
self.relay.closePhidget()
return
else :
print('Failed to connect to Phidget controller')
self.master.update()
self.relay.closePhidget()
return
else :
print('Failed to connect to Phidget controller')
self.master.update()
self.relay.closePhidget()
return
def bbias_on_button(self):
# This is called when bbias_on is called from the GUI.
# It requires confirmation so as not to damage the device.
if self.bbias_on_confirm_ent.get() != 'Y':
print "The device can be damaged if backbias is connected before power up."
print "Make certain that you have run ccd_setup before bbias_on."
print "If you are certain, enter 'Y' in the confirm box"
print "Not connecting bbias. BSS is still off.\n"
self.master.update()
self.bbias_on_confirm_ent.delete(0,END)
self.bbias_on_confirm_ent.insert(0,'')
return
else:
self.bbias_on()
self.bbias_on_confirm_ent.delete(0,END)
self.bbias_on_confirm_ent.insert(0,'')
return
def bbias_off(self):
"""Python version of the bbias_off script"""
print('Connecting to BSS controller...')
# First set the voltage off at the BK and turn the output off
self.bk.Set_Voltage(0.0)
self.bk.bbias_off()
time.sleep(0.5)
if self.bss_relay_status:
self.relay.openPhidget(403840) # Serial number 403840 is the Vbb control Phidgets relay
self.relay.waitForAttach(10000)
if (self.relay.isAttached() and self.relay.getSerialNum() == 403840):
self.relay.setOutputState(0,False)
print('BSS is now OFF')
print('Done!')
self.relay.closePhidget()
return
else :
sys.exit('Failed to connect to Phidget controller')
self.relay.closePhidget()
return
else :
print('Failed to connect to Phidget controller')
self.relay.closePhidget()
return
def sixteen_ch_setup(self):
"""Python version of the CamCmd 16ch_setup script"""
print "Setting up for generic 16 channel readout...\n"
# initialize edt interface
InitFile = eolib.getCfgVal(self.CfgFile,"INIT_FILE")
if not self.CheckIfFileExists(InitFile):
print "Init File not found. Exiting sixteen channel setup"
return
#self.runcmd(["initrcx0"]) # This script just does the following:
self.runcmd([self.EDTdir+"/initcam", "-u", "0", "-c", "0", "-f", InitFile])
self.runcmd([self.edtsaodir+"/crst"]) # Camera reset
# Turn off the greyscale generator
print "Turning greyscale generator off\n"
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "30400000"]) # ad board #1 gray scale off
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "31400000"]) # ad board #2 gray scale off
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "32400000"]) # ad board #3 gray scale off
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "33400000"]) # ad board #4 gray scale off
# Set the system gain to high
# Note that this gets over-ridden in ccd_setup.
self.gain("HIGH")
# Set unidirectional mode
print "Setting unidirectional CCD serial shift mode\n"
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "43000001"]) # uni on
# Set split mode on. "Why on?" you ask. Beats me.
print "Setting CCD serial register shifts to split mode\n"
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "41000001"]) # split on
self.ccd_channels()
print "Setting default ADC offsets\n"
self.ccd_offsets()
self.Check_Communications()
print "16ch_setup Done.\n"
self.master.update()
return
def exp_acq(self, exptime=0.0, fitsfilename='test.fits'):
"""Python version of the CamCmd exp_acq script"""
NoFlushFile = eolib.getCfgVal(self.CfgFile,"EXP_NO_FLUSH_FILE")
if not self.CheckIfFileExists(NoFlushFile):
print "No Flush File not found. Exiting exp_acq"
return
FlushFile = eolib.getCfgVal(self.CfgFile,"EXP_FLUSH_FILE")
if not self.CheckIfFileExists(FlushFile):
print "Flush File not found. Exiting exp_acq"
return
#print "Before fclr, time = ",time.time()
self.runcmd([self.edtsaodir+"/fclr", "2"]) # clear the CCD
#print "After fclr, time = ",time.time()
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "50000080"]) # setup for tens of millisecond exposure time
#print "After edtwriten, time = ",time.time()
self.runcmd([self.edtsaodir+"/edtwriteblk", "-f", NoFlushFile]) # load the signal file to stop parallel flushing
#print "After edtwriteblk, time = ",time.time()
self.runcmd([self.edtsaodir+"/expose", str(exptime)]) # do the exposure
#print "After expose, time = ",time.time()
time.sleep(1.0) # delay for shutter to close all the way?
#print "Before image16, time = ",time.time()
if self.vendor == "ITL":
self.runcmd([self.edtsaodir+"/image16", "-F", "-f", fitsfilename, "-x", "542", "-y", "2022", "-n", "16"]) # readout
elif self.vendor == "E2V":
self.runcmd([self.edtsaodir+"/image16", "-F", "-f", fitsfilename, "-x", "572", "-y", "2048", "-n", "16"]) # readout
self.runcmd([self.edtsaodir+"/edtwriteblk", "-f", FlushFile]) # load the signal file to re-start parallel flushing
#print "After edtwriteblk, time = ",time.time()
return
def dark_acq(self, exptime=0.0, fitsfilename='test.fits'):
"""Python version of the CamCmd dark_acq script"""
NoFlushFile = eolib.getCfgVal(self.CfgFile,"DARK_NO_FLUSH_FILE")
if not self.CheckIfFileExists(NoFlushFile):
print "No Flush File not found. Exiting dark_acq"
self.master.update()
return
FlushFile = eolib.getCfgVal(self.CfgFile,"DARK_FLUSH_FILE")
if not self.CheckIfFileExists(FlushFile):
print "Flush File not found. Exiting dark_acq"
self.master.update()
return
self.runcmd([self.edtsaodir+"/fclr", "2"]) # clear the CCD
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "50000080"]) # setup for tens of millisecond exposure time
self.runcmd([self.edtsaodir+"/edtwriteblk", "-f", NoFlushFile]) # load the signal file to stop parallel flushing
self.runcmd([self.edtsaodir+"/dark", str(exptime)]) # do the exposure
if self.vendor == "ITL":
self.runcmd([self.edtsaodir+"/image16", "-F", "-f", fitsfilename, "-x", "542", "-y", "2022", "-n", "16"]) # readout
elif self.vendor == "E2V":
self.runcmd([self.edtsaodir+"/image16", "-F", "-f", fitsfilename, "-x", "572", "-y", "2048", "-n", "16"]) # readout
self.runcmd([self.edtsaodir+"/edtwriteblk", "-f", FlushFile]) # load the signal file to re-start parallel flushing
return
def ccd_setup(self):
"""Python version of the sta3800_setup script"""
self.GetVoltageLookup()
self.sixteen_ch_setup()
print "Setting up CCD ...\n"
self.master.update()
self.ccd_timing()
self.ccd_channels()
self.ccd_volts()
self.ccd_offsets()
gain = eolib.getCfgVal(self.CfgFile,"GAIN_MODE")
self.gain(gain)
print "ccd_setup done.\n"
self.master.update()
return
def ccd_off(self):
"""Python version of the sta3800_off script"""
print"Powering down the ccd device...\n"
self.GetVoltageLookup()
self.bbias_off()
time.sleep(0.5)
supplies = self.voltage_lookup
supplies.reverse()
# Powering down in reverse order of power up
for supply in supplies:
name = supply["Name"]
vmin = supply["Vmin"]
vmax = supply["Vmax"]
value = 0.0
if value < vmin or value > vmax:
print "Requested voltage for %s exceeds limits. Exiting voltage setup\n"%name
return
if vmin < 0.0:
DACval = int(round(4095 - round(round((value - vmin) / (vmax - vmin), 3) * 4095, 3), 0))
else:
DACval = int(round(round((value - vmin) / (vmax - vmin), 3) * 4095, 0))
for chan in supply["chan"]:
print "Command= %s"%(self.edtsaodir+"/edtwriten -c %s%03x"%(chan,DACval))
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "%s%03x"%(chan,DACval)])
#print "Set Voltage %s to %.2f volts: at ADC channel %s DAC setting %03x"%(name,value,chan,DACval)
print "Set Voltage %s to %.2f volts"%(name,value)
time.sleep(0.1)
print "ccd_off done.\n"
return
def gain(self, value):
"""Python version of the CamCmds gain script"""
if value == "LOW":
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "50200000"])
print 'Setting gain to LOW.\n'
elif value == "HIGH":
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "50300000"])
print 'Setting gain to HIGH.\n'
else:
print "Bogus gain setting\n"
print 'Usage: gain("LOW") or gain("HIGH")\n'
self.master.update()
return
def ccd_timing(self):
"""Python version of the sta3800_timing script"""
print "Setting up CCD default timing...\n"
Par_Clk_Delay = int(eolib.getCfgVal(self.CfgFile,"PAR_CLK_DELAY"))
print "Setting parallel clock delay to %d\n"%Par_Clk_Delay
self.master.update()
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "46000%03x"%Par_Clk_Delay]) # Set parallel clock delay to 6
SigBFile = eolib.getCfgVal(self.CfgFile,"TIM_FILE")
if not self.CheckIfFileExists(SigBFile):
print "Signal file not found. May need to run Perl conversion routine. Exiting ccd_timing"
return
print "Loading serial readout signal file %s\n"%SigBFile
self.master.update()
self.runcmd([self.edtsaodir+"/edtwriteblk", "-f", SigBFile]) # load the signal file
PatBFile = eolib.getCfgVal(self.CfgFile,"PAT_FILE")
if not self.CheckIfFileExists(PatBFile):
print "Pattern file not found. May need to run Perl conversion routine. Exiting ccd_timing"
self.master.update()
return
print "Loading default pattern file %s\n"%PatBFile
self.master.update()
self.runcmd([self.edtsaodir+"/edtwriteblk", "-f", PatBFile]) # load the pattern file
print "ccd_timing done.\n"
self.master.update()
return
def ccd_offsets(self):
"""Python version of the sta3800_offsets script"""
self.GetOffsetLookup()
for segment in self.offset_lookup:
seg = segment["Segment"]
chan = segment["chan"]
channel = segment["Channel"]
offset = segment["offset"]
if offset > 2047 or offset < -2048 :
print "Offset value outside of -2048 to +2047 limit. Offsets not done."
self.master.update()
return
elif offset >= 0:
dac_offset = offset
else:
dac_offset = 4096 + offset
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "%s0%03x"%(chan,dac_offset)])
print "Set segment %2d offset to %4d"%(seg,offset)
self.master.update()
print "ccd_offsets done.\n"
self.master.update()
return
def ccd_volts(self):
"""Python version of the sta3800_volts script"""
print "Setting up ccd default voltages...\n"
self.master.update()
self.GetVoltageLookup()
self.bbias_off()
time.sleep(0.5)
supplies = self.voltage_lookup
for supply in supplies:
name = supply["Name"]
vmin = supply["Vmin"]
vmax = supply["Vmax"]
value = supply["Value"]
if value < vmin or value > vmax:
print "Requested voltage for %s exceeds limits. Exiting voltage setup\n"%name
self.master.update()
return
if vmin < 0.0:
DACval = int(round(4095 - round(round((value - vmin) / (vmax - vmin), 3) * 4095, 3), 0))
else:
DACval = int(round(round((value - vmin) / (vmax - vmin), 3) * 4095, 0))
for chan in supply["chan"]:
print "Command= %s"%(self.edtsaodir+"/edtwriten -c %s%03x"%(chan,DACval))
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "%s%03x"%(chan,DACval)])
#print "Set Voltage %s to %.2f volts: at ADC channel %s DAC setting %03x"%(name,value,chan,DACval)
print "Set Voltage %s to %.2f volts"%(name,value)
self.master.update()
time.sleep(0.1)
self.bbias_on()
print "ccd_volts done.\n"
self.master.update()
return
def ccd_channels(self):
"""Python version of the sta3800_channels script"""
print "Setting up for 16 channel readout...\n"
self.master.update()
# We want them in order, and we want all of them
print "Set up channel readout order to 0,1,2,3...15\n"
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000042"]) # Board 0
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000140"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000243"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000341"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000446"]) # Board 1
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000544"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000647"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000745"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "5100084d"]) # Board 2
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "5100094f"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000a4c"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000b4e"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000c49"]) # Board 3
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000d4b"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51000e48"]) #
self.runcmd([self.edtsaodir+"/edtwriten", "-c", "51008f4a"]) #
print "ccd_channels done.\n"
self.master.update()
return
class LTCPhidget(object):
# TODO: can the remote specific events find a disconnected usb cable?
devserial = 0
IP = "0.0.0.0"
port = 0
input = {}
output = {}
sensor = {}
callback = {'attach': [],
'detach': [],
'error': [],
'output': [],
'input': [],
'sensor': []}
def __init__(self, **kwargs):
log.debug("Acquiring InterfaceKit")
self.ik = InterfaceKit()
log.debug("Registering Handlers")
self.ik.setOnAttachHandler(self._onAttach)
self.ik.setOnDetachHandler(self._onDetach)
self.ik.setOnErrorhandler(self._onError)
self.ik.setOnOutputChangeHandler(self._onOutput)
self.ik.setOnInputChangeHandler(self._onInput)
self.ik.setOnSensorChangeHandler(self._onSensor)
def start(self):
log.verbose("Opening remote IP")
self.ik.openRemoteIP(self.IP, self.port, self.devserial)
log.debug("Remote IP opened")
def close(self):
log.verbose("Closing InterfaceKit")
self.ik.closePhidget()
log.debug("Interfac kit closed")
def add_callback(self, cb, type):
log.debug("Adding a {} type callback".format(type))
self.callback[type].append(cb)
def remove_callback(self, cb, type):
log.debug("Removing a {} type callback".format(type))
self.callback[type].remove(cb)
def _genericCB(self, event, type):
log.verbose("{} event received".format(type))
for cb in self.callback[type]:
cb(event)
for dev in self.input.itervalues():
for cb in dev.callback[type]:
cb(event)
for dev in self.output.itervalues():
for cb in dev.callback[type]:
cb(event)
for dev in self.sensor.itervalues():
for cb in dev.callback[type]:
cb(event)
def _onAttach(self, event):
self._genericCB(event, 'attach')
def _onDetach(self, event):
self._genericCB(event, 'detach')
def _onError(self, event):
log.debug(event.description)
log.verbose("{} event received".format(type))
for cb in self.callback['error']:
cb(event)
def _onOutput(self, event):
log.verbose("Output event received")
for cb in self.callback['output']:
cb(event)
try:
for cb in self.output[event.index].callback['value']:
cb(event)
except KeyError:
pass
def _onInput(self, event):
log.verbose("Input event received")
for cb in self.callback['input']:
cb(event)
try:
for cb in self.input[event.index].callback['value']:
cb(event)
except KeyError:
pass
def _onSensor(self, event):
log.verbose("Sensor event received")
for cb in self.callback['sensor']:
cb(event)
try:
for cb in self.sensor[event.index].callback['value']:
cb(event)
except KeyError:
pass
class PowerControl(object):
''' PowerControl class wraps language around the 1014_2 -
PhidgetInterfaceKit 0/0/4 4 relay device. '''
def __init__(self):
#log.info("Start of power control object")
pass
def open_phidget(self):
''' Based on the InterfaceKit-simple.py example from Phidgets, create an
relay object, attach the handlers, open it and wait for the attachment.
This function's primarily purpose is to replace the prints with log
statements. '''
try:
self.interface = InterfaceKit()
except RuntimeError as e:
log.critical("Phidget runtime exception: %s" % e.details)
return 0
try:
self.interface.setOnAttachHandler( self.interfaceAttached )
self.interface.setOnDetachHandler( self.interfaceDetached )
self.interface.setOnErrorhandler( self.interfaceError )
except PhidgetException as e:
log.critical("Phidget Exception %i: %s" % (e.code, e.details))
return 0
try:
#print "Force open relay serial: 290968"
self.interface.openPhidget()
except PhidgetException as e:
log.critical("Phidget Exception %i: %s" % (e.code, e.details))
return 0
#log.info("Waiting for attach....")
try:
self.interface.waitForAttach(100)
except PhidgetException as e:
log.critical("Phidget Exception %i: %s" % (e.code, e.details))
try:
self.interface.closePhidget()
except PhidgetException as e:
log.critical("Close Exc. %i: %s" % (e.code, e.details))
return 0
return 1
#Event Handler Callback Functions
def interfaceAttached(self, e):
attached = e.device
#log.info("interface %i Attached!" % (attached.getSerialNum()))
def interfaceDetached(self, e):
detached = e.device
log.info("interface %i Detached!" % (detached.getSerialNum()))
def interfaceError(self, e):
try:
source = e.device
log.critical("Interface %i: Phidget Error %i: %s" % \
(source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
log.critical("Phidget Exception %i: %s" % (e.code, e.details))
def close_phidget(self):
try:
self.interface.closePhidget()
except PhidgetException as e:
log.critical("Phidget Exception %i: %s" % (e.code, e.details))
return 0
return 1
def change_relay(self, relay=0, status=0):
''' Toggle the status of the phidget relay line to low(0) or high(1)'''
try:
self.interface.setOutputState(relay, status)
#self.emit_line_change(relay, status)
except Exception as e:
log.critical("Problem setting relay on %s" % e)
return 0
return 1
''' Convenience functions '''
def zero_on(self):
#log.info("Zero relay on")
return self.change_relay(relay=ZERO_RELAY, status=1)
def zero_off(self):
return self.change_relay(relay=ZERO_RELAY, status=0)
def one_on(self):
#log.info("one relay on")
return self.change_relay(relay=ONE_RELAY, status=1)
def one_off(self):
return self.change_relay(relay=ONE_RELAY, status=0)
def two_on(self):
#log.info("two relay on")
return self.change_relay(relay=TWO_RELAY, status=1)
def two_off(self):
return self.change_relay(relay=TWO_RELAY, status=0)
def three_on(self):
#log.info("two relay on")
return self.change_relay(relay=THREE_RELAY, status=1)
def three_off(self):
return self.change_relay(relay=THREE_RELAY, status=0)
def toggle_line(self, line=0):
''' Read the internal state of the specified line, then set the opposite
state for a toggle function'''
if not self.open_phidget():
log.critical("Problem opening phidget")
return 0
try:
curr_state = self.interface.getOutputState(line)
except Exception as e:
log.critical("Problem getting relay on %s" % e)
self.close_phidget()
return 0
if not self.change_relay(line, not curr_state):
log.critical("Problem changing relay")
return 0
if not self.close_phidget():
log.criticla("Problem closing phidget")
return 0
return 1
interfaceKit.openPhidget(120683)
interfaceKit_Relay.openPhidget(352936) #added
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for attach....")
try:
interfaceKit.waitForAttach(10000)
interfaceKit_Relay.waitForAttach(10000) #added
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
interfaceKit.closePhidget(120683)
# interfaceKit_Relay.closePhidget(352936) #added
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
else:
displayDeviceInfo()
print("Setting the data rate for each sensor index to 4ms....")
for i in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(i, 4)
class System(DataSourceSystem):
'''
Generic DataSourceSystem interface for the Phidgets board: http://www.phidgets.com/products.php?category=0&product_id=1018_2
'''
update_freq = 1000
def __init__(self, n_sensors=2, n_inputs=1):
'''
Docstring
Parameters
----------
Returns
-------
'''
self.n_sensors = n_sensors
self.n_inputs = n_inputs
self.interval = 1. / self.update_freq
self.sensordat = np.zeros((n_sensors,))
self.inputdat = np.zeros((n_inputs,), dtype=np.bool)
self.data = np.zeros((1,), dtype=self.dtype)
self.kit = InterfaceKit()
self.kit.openPhidget()
self.kit.waitForAttach(2000)
def start(self):
'''
Docstring
Parameters
----------
Returns
-------
'''
self.tic = time.time()
def stop(self):
'''
Docstring
Parameters
----------
Returns
-------
'''
pass
def get(self):
'''
Docstring
Parameters
----------
Returns
-------
'''
toc = time.time() - self.tic
if 0 < toc < self.interval:
time.sleep(self.interval - toc)
try:
for i in range(self.n_sensors):
self.sensordat[i] = self.kit.getSensorValue(i) / 1000.
for i in range(self.n_inputs):
self.inputdat[i] = self.kit.getInputState(i)
except:
print 'sensor_error'
self.data['sensors'] = self.sensordat
self.data['inputs'] = self.inputdat
self.tic = time.time()
return self.data
def sendMsg(self, msg):
'''
Docstring
Parameters
----------
Returns
-------
'''
pass
def __del__(self):
'''
Docstring
Parameters
----------
Returns
-------
'''
self.kit.closePhidget()
try:
interfaceKit.openRemoteIP("192.168.128.2", port=5001, serial=SERIAL_NUM)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for attach....")
try:
interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
while True:
sleep(1)
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
class InterfaceKitHelper:
__inputs = np.zeros(8)
__sensors = np.zeros(8)
attached = False
led = None
def __init__(self):
# Create an interfacekit object
try:
self.__interfaceKit = InterfaceKit()
except RuntimeError as e:
print('Runtime Exception: %s' % e.details)
return 1
try:
# logging example, uncomment to generate a log file
#self.__interfaceKit.enableLogging(PhidgetLogLevel.PHIDGET_LOG_VERBOSE, 'phidgetlog.log')
self.__interfaceKit.setOnAttachHandler(self.__interfaceKitAttached)
self.__interfaceKit.setOnDetachHandler(self.__interfaceKitDetached)
self.__interfaceKit.setOnErrorhandler(self.__interfaceKitError)
self.__interfaceKit.setOnInputChangeHandler(
self.__interfaceKitInputChanged)
self.__interfaceKit.setOnOutputChangeHandler(
self.__interfaceKitOutputChanged)
self.__interfaceKit.setOnSensorChangeHandler(
self.__interfaceKitSensorChanged)
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
return 1
print('[INFO] [InterfaceKitHelper] Opening phidget object....')
try:
self.__interfaceKit.openPhidget()
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
return 1
print('[INFO] [InterfaceKitHelper] Waiting for attach....')
try:
self.__interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
try:
self.__interfaceKit.closePhidget()
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
return 1
return 1
else:
# self.__displayDeviceInfo()
pass
print(
'[INFO] [InterfaceKitHelper] Setting the data rate for each sensor index to 4ms....'
)
for i in range(self.__interfaceKit.getSensorCount()):
try:
self.__interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
self.led = LED(self)
def getInputs(self):
return InterfaceKitHelper.__inputs[:]
def getSensors(self):
return InterfaceKitHelper.__sensors[:]
def setOutputState(self, *args):
if self.attached:
self.__interfaceKit.setOutputState(*args)
def destroy(self):
self.attached = False
self.led.destroy()
try:
print(
'[INFO] [InterfaceKitHelper] Closing interface kit phidget...')
self.__interfaceKit.closePhidget()
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
return 1
def __displayDeviceInfo(self):
"""
Information Display Function
"""
print(
'|------------|----------------------------------|--------------|------------|'
)
print(
'|- Attached -|- Type -|- Serial No. -|- Version -|'
)
print(
'|------------|----------------------------------|--------------|------------|'
)
print('|- %8s -|- %30s -|- %10d -|- %8d -|' %
(self.__interfaceKit.isAttached(),
self.__interfaceKit.getDeviceName(),
self.__interfaceKit.getSerialNum(),
self.__interfaceKit.getDeviceVersion()))
print(
'|------------|----------------------------------|--------------|------------|'
)
print('Number of Digital Inputs: %i' %
(self.__interfaceKit.getInputCount()))
print('Number of Digital Outputs: %i' %
(self.__interfaceKit.getOutputCount()))
print('Number of Sensor Inputs: %i' %
(self.__interfaceKit.getSensorCount()))
def __interfaceKitAttached(self, e):
"""
Event Handler Callback Functions
"""
attached = e.device
print('[INFO] [InterfaceKitHelper] InterfaceKit %i Attached!' %
(attached.getSerialNum()))
self.attached = True
def __interfaceKitDetached(self, e):
detached = e.device
print('[INFO] [InterfaceKitHelper] InterfaceKit %i Detached!' %
(detached.getSerialNum()))
self.attached = False
def __interfaceKitError(self, e):
try:
source = e.device
print(
'[INFO] [InterfaceKitHelper] InterfaceKit %i: Phidget Error %i: %s'
% (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print('[ERROR] Phidget Exception %i: %s' % (e.code, e.details))
def __interfaceKitInputChanged(self, e):
# source = e.device
# print('InterfaceKit %i: Input %i: %s' % (source.getSerialNum(), e.index, e.state))
InterfaceKitHelper.__inputs[e.index] = e.state
def __interfaceKitSensorChanged(self, e):
# source = e.device
# print('InterfaceKit %i: Sensor %i: %i' % (source.getSerialNum(), e.index, e.value))
InterfaceKitHelper.__sensors[e.index] = e.value
def __interfaceKitOutputChanged(self, e):
# source = e.device
# print('InterfaceKit %i: Output %i: %s' % (source.getSerialNum(), e.index, e.state))
pass
class Pot:
__sensorPort = 1
__sampleRate = 4 # Maybe too high?
__potMin = 242
__potZero = 490
__potMax = 668
def __init__(self):
#Create an interfacekit object
try:
self.interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
self.interfaceKit.openPhidget()
self.interfaceKit.waitForAttach(10000)
self.interfaceKit.setDataRate(self.__sensorPort, self.__sampleRate)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
def __del__(self):
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
def getRawPot(self):
try:
resp = self.interfaceKit.getSensorValue(self.__sensorPort)
except PhidgetException as e:
# suppress print (makes testing harder) #TODO restore!!
resp = float('nan')
#print("Skipping reading - phidget Exception %i: %s" % (e.code, e.details))
return resp
#def recconect(self):
def getPot(self):
rawSensor = self.getRawPot()
value = 0.0
if rawSensor > self.__potMax:
#warnings.warn("Pot measuremens out of bounds.")
return 1.0
if rawSensor < self.__potMin:
#warnings.warn("Pot measuremens out of bounds.")
return -1.0
if rawSensor >= self.__potZero:
value = float(rawSensor - self.__potZero) / (self.__potMax - self.__potZero)
else:
value = float(rawSensor - self.__potZero) / (self.__potZero - self.__potMin)
return value
def connect_to_phidget(SensorChangedFunction, serial_number=None):
#Create an interfacekit object
try:
interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
#Information Display Function
def displayDeviceInfo():
print("|------------|----------------------------------|--------------|------------|")
print("|- Attached -|- Type -|- Serial No. -|- Version -|")
print("|------------|----------------------------------|--------------|------------|")
print("|- %8s -|- %30s -|- %10d -|- %8d -|" % (interfaceKit.isAttached(), interfaceKit.getDeviceName(), interfaceKit.getSerialNum(), interfaceKit.getDeviceVersion()))
print("|------------|----------------------------------|--------------|------------|")
print("Number of Digital Inputs: %i" % (interfaceKit.getInputCount()))
print("Number of Digital Outputs: %i" % (interfaceKit.getOutputCount()))
print("Number of Sensor Inputs: %i" % (interfaceKit.getSensorCount()))
#Event Handler Callback Functions
def interfaceKitAttached(e):
attached = e.device
print("InterfaceKit %i Attached!" % (attached.getSerialNum()))
def interfaceKitDetached(e):
detached = e.device
print("InterfaceKit %i Detached!" % (detached.getSerialNum()))
def interfaceKitError(e):
try:
source = e.device
print("InterfaceKit %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
#Main Program Code
try:
interfaceKit.setOnAttachHandler(interfaceKitAttached)
interfaceKit.setOnDetachHandler(interfaceKitDetached)
interfaceKit.setOnErrorhandler(interfaceKitError)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Opening phidget object....")
try:
if serial_number is not None:
interfaceKit.openPhidget(serial_number)
else:
interfaceKit.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for attach....")
try:
interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
else:
displayDeviceInfo()
phidget = interfaceKit
return phidget
s = dict()
s['sens'] = np.zeros((1,2))
s['start_time'] = time.time()
sec_of_dat = 600
f_s = 60
err_ind = []
for i in range(sec_of_dat*f_s):
s['tic'] = time.time()
sensdat = np.zeros((1,2))
try:
sensdat[0,0] = kit.getSensorValue(0)/1000.
sensdat[0,1] = kit.getSensorValue(1)/1000.
except:
print time.time() - s['start_time'], i
print kit.isAttached()
err_ind.extend([i])
try:
print kit.getSensorRawValue(2), kit.getSensorValue(2)
except:
print 'novalue'
s['sens'] = np.vstack((s['sens'], sensdat))
left_over_time = np.max([0, 1000/60. - (time.time() - s['tic'])])
time.sleep(left_over_time/1000.)
kit.closePhidget()
plt.plot(np.array(err_ind)/float(f_s))
class DewarFill(object):
def __init__(self, master):
self.master = master
self.fill_log_name='/sandbox/lsst/lsst/GUI/particles/fill_log.dat'
self.valve = InterfaceKit()
self.comm_status = False
self.ov_temp = 999.0
self.valve_state = "Closed"
return
def Check_Communications(self):
# Checks on communications status with the Dewar Fill relay
self.comm_status = False
try:
self.valve.openPhidget(431944) # Serial number 431944 is the Dewar valve Phidget
self.valve.waitForAttach(10000)
if self.valve.isAttached() and self.valve.getSerialNum() == 431944:
self.comm_status = True
self.valve.closePhidget()
print "Successfully initialized DewarFill Relay\n"
sys.stdout.flush()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print "Failed to initialize DewarFill Relay\n"
sys.stdout.flush()
self.valve.closePhidget()
return
def StartFill(self):
# Opens the Dewar fill valve
try:
self.valve.openPhidget(431944) # Serial number 431944 is the Dewar valve Phidget
self.valve.waitForAttach(1000)
if self.valve.isAttached() and self.valve.getSerialNum() == 431944:
time.sleep(0.1)
self.valve.setOutputState(0,True) # This opens the valve
self.valve.setOutputState(1,True)
time.sleep(2.0)
self.valve.closePhidget()
self.valve.openPhidget(431944) # Serial number 431944 is the Dewar valve Phidget
self.valve.waitForAttach(1000)
if self.valve.isAttached() and self.valve.getSerialNum() == 431944:
time.sleep(0.1)
state0 = self.valve.getOutputState(0)
state1 = self.valve.getOutputState(1)
if state0 and state1:
time.sleep(0.1)
self.valve.closePhidget()
print "Successfully initiated Dewar fill at ", datetime.datetime.now()
sys.stdout.flush()
time.sleep(0.1)
self.valve.closePhidget()
time.sleep(0.1)
return True
else:
print "Error 1 in initiating Dewar fill at ", datetime.datetime.now()
sys.stdout.flush()
self.valve.closePhidget()
return False
except PhidgetException as e:
print "Error 2 in initiating Dewar fill at ", datetime.datetime.now()
print("Phidget Exception %i: %s" % (e.code, e.details))
sys.stdout.flush()
self.valve.closePhidget()
return False
def StopFill(self):
# Closes the Dewar fill valve
try:
self.valve.openPhidget(431944) # Serial number 431944 is the Dewar valve Phidget
self.valve.waitForAttach(1000)
if self.valve.isAttached() and self.valve.getSerialNum() == 431944:
time.sleep(0.1)
self.valve.setOutputState(0,False) # This closes the valve
self.valve.setOutputState(1,False)
time.sleep(1.0)
self.valve.closePhidget()
self.valve.openPhidget(431944) # Serial number 431944 is the Dewar valve Phidget
self.valve.waitForAttach(1000)
if self.valve.isAttached() and self.valve.getSerialNum() == 431944:
time.sleep(0.1)
state0 = self.valve.getOutputState(0)
state1 = self.valve.getOutputState(1)
if not state0 and not state1:
time.sleep(0.1)
self.valve.closePhidget()
print "Successfully terminated Dewar fill at ", datetime.datetime.now()
sys.stdout.flush()
time.sleep(0.1)
self.valve.closePhidget()
time.sleep(0.1)
return True
else:
print "Error 1 in terminating Dewar fill at ", datetime.datetime.now()
sys.stdout.flush()
self.valve.closePhidget()
return False
except PhidgetException as e:
print "Error 2 in terminating Dewar fill at ", datetime.datetime.now()
print("Phidget Exception %i: %s" % (e.code, e.details))
sys.stdout.flush()
self.valve.closePhidget()
return False
def MeasureOverFlowTemp(self):
# Measures the temperature in the overflow cup
# returns both the valve state and the temperature
try:
self.valve.openPhidget(431944) # Serial number 431944 is the Dewar valve Phidget
self.valve.waitForAttach(1000)
if self.valve.isAttached() and self.valve.getSerialNum() == 431944:
sensor = self.valve.getSensorValue(6)
NumTries = 0
while sensor < 0.01 and NumTries < 5:
time.sleep(0.1)
sensor = self.valve.getSensorValue(6)
NumTries += 1
self.ov_temp = sensor * 0.2222 - 61.111
state0 = self.valve.getOutputState(0)
state1 = self.valve.getOutputState(1)
state = state0 and state1
if state:
self.valve_state = "Open"
if not state:
self.valve_state = "Closed"
self.valve.closePhidget()
return [state, self.ov_temp]
else:
self.valve.closePhidget()
return [False, 999.0]
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
sys.stdout.flush()
self.valve.closePhidget()
return [False, 999.0]
def MeasureOverFlowTempGUI(self):
# Measures the temperature in the overflow cup
[state, temp] = self.MeasureOverFlowTemp()
if state:
self.valve_state = "Open"
if not state:
self.valve_state = "Closed"
self.ovtemp_text.set("Overflow Temp="+str(self.ov_temp)+" Valve State="+self.valve_state)
return
def LogFill(self):
# Logs the Dewar Fill
jd = Time(datetime.datetime.now(), format='datetime').jd
out = "%.4f \n"%(jd)
file = open(self.fill_log_name, 'a')
file.write(out)
file.close()
time.sleep(0.1)
return
def Define_Frame(self):
""" Dewar Fill frame in the Tk GUI. Defines buttons and their location"""
self.frame=Frame(self.master, relief=GROOVE, bd=4)
self.frame.grid(row=3,column=4,rowspan=1,columnspan=2)
frame_title = Label(self.frame,text="Manual Dewar Fill",relief=RAISED,bd=2,width=36, bg="light yellow",font=("Times", 16))
frame_title.grid(row=0, column=0)
fill_but = Button(self.frame, text="Start Dewar Fill", width=36, command=self.StartFill)
fill_but.grid(row=1,column=0)
stop_but = Button(self.frame, text="Stop Dewar Fill", width=20, command=self.StopFill)
stop_but.grid(row=2,column=0)
log_but = Button(self.frame, text="Log Dewar Fill", width=20, command=self.LogFill)
log_but.grid(row=3,column=0)
ovtemp_but = Button(self.frame, text="Check Overflow Temp", width=16,command=self.MeasureOverFlowTempGUI)
ovtemp_but.grid(row=4,column=0)
self.ovtemp_text=StringVar()
ovtemp_out = Label(self.frame,textvariable=self.ovtemp_text)
self.ovtemp_text.set("Overflow Temp="+str(self.ov_temp)+" Valve State="+self.valve_state)
ovtemp_out.grid(row=5,column=0)
return
print("Exiting....")
exit(1)
#if not interfaceKitHUB.isAttachedToServer():
# sleep(2)
print("Waiting for attach....")
try:
interfaceKitHUB.waitForAttach(10000)
#interfaceKitLCD.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
interfaceKitHUB.closePhidget()
#interfaceKitLCD.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
else:
displayDeviceInfo()
#print("Setting the data rate for each sensor index to 4ms....")
for i in range(interfaceKitHUB.getSensorCount()):
try:
interfaceKitHUB.setDataRate(i, 2)
def main():
try:
interfaceKit = InterfaceKit()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
interfaceKit.setOnAttachHandler(inferfaceKitAttached)
interfaceKit.setOnDetachHandler(interfaceKitDetached)
interfaceKit.setOnErrorhandler(interfaceKitError)
interfaceKit.setOnInputChangeHandler(interfaceKitInputChanged)
interfaceKit.setOnOutputChangeHandler(interfaceKitOutputChanged)
interfaceKit.setOnSensorChangeHandler(interfaceKitSensorChanged)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Opening phidget object....")
try:
interfaceKit.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for attach....")
try:
interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
print("Setting the data rate for each sensor index to 4ms....")
for i in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
sys.exit(app.exec_())
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
class PHIDGET_IFK(object):
""" Phidget InterfaceKit """
def __init__(self, serialNumber=None, waitForAttach=1000, **kargs):
self.interfaceKit = InterfaceKit()
if 'remoteHost' in kargs:
self.interfaceKit.openRemote(kargs['remoteHost'], serialNumber)
else:
self.interfaceKit.openPhidget(serialNumber)
self.ratiometric = 1
if 'ratiometric' in kargs:
self.ratiometric = kargs['ratiometric']
h = [
'onAttachHandler',
'onDetachHandler',
'onErrorhandler',
'onInputChangeHandler',
'onOutputChangeHandler',
'onSensorChangeHandler'
]
for event in h:
self.__dict__[event] = None
if event in kargs:
self.__dict__[event] = kargs[event]
self.interfaceKit.setOnAttachHandler(self.attached)
self.interfaceKit.setOnDetachHandler(self.detached)
self.interfaceKit.setOnErrorhandler(self.error)
self.interfaceKit.setOnInputChangeHandler(self.inputChanged)
self.interfaceKit.setOnOutputChangeHandler(self.outputChanged)
self.interfaceKit.setOnSensorChangeHandler(self.sensorChanged)
if waitForAttach > 0:
try:
self.interfaceKit.waitForAttach(waitForAttach)
except PhidgetException as e:
#print("Phidget Exception %i: %s" % (e.code, e.details))
try:
self.interfaceKit.closePhidget()
except PhidgetException as e2:
pass
raise e
def attached(self, e):
self.interfaceKit.setRatiometric(self.ratiometric)
time.sleep(0.05)
if self.onAttachHandler: self.onAttachHandler(e)
def detached(self, e):
if self.onDetachHandler: self.onDetachHandler(e)
def error(self, e):
error = {'code': e.eCode, 'description': e.description}
if self.onErrorhandler: self.onErrorhandler(error, e)
def outputChanged(self, e):
if self.onInputChangeHandler: self.onInputChangeHandler(e.index, e.state, e)
def inputChanged(self, e):
if self.onInputChangeHandler: self.onInputChangeHandler(e.index, e.state, e)
def sensorChanged(self, e):
if self.onInputChangeHandler: self.onInputChangeHandler(e.index, e.value, e)
class Node(object):
name = None
sensors = []
outputs = []
inputs = []
triggers = []
clocks = []
repeaters = []
interface_kit = None
def __init__(self, name, *args, **kwargs):
self.name = name
self.initializing = True
if LIVE: self.interface_kit = InterfaceKit()
self.manager = PubSub(self, pub_port=settings.NODE_PUB, sub_port=settings.NODE_SUB, sub_filter=self.name)
self.logger = util.get_logger("%s.%s" % (self.__module__, self.__class__.__name__))
self.initialize()
self.run()
def initialize(self):
while self.initializing:
self.logger.info("Waiting for manager")
json = dict(name=self.name, method='add_node')
self.publish(json)
gevent.sleep(1)
return
def publish(self, message):
message['name'] = self.name
message['method'] = message.get('method', 'node_change')
self.manager.publish(aes.encrypt(json.dumps(message, cls=ComplexEncoder), settings.KEY))
self.test_triggers(message)
def test_triggers(self, message):
for t in self.triggers:
t.handle_event(message)
def initialize_rpc(self, obj, **kwargs):
rpc = zmq.Context()
rpc_socket = rpc.socket(zmq.REP)
rpc_socket.bind("tcp://*:%s" % obj.get('port'))
self.logger.info("RPC listening on: %s" % obj.get('port'))
settings.KEY = base64.urlsafe_b64decode(str(obj.get('key')))
self.logger.info("%s Initialized" % self.name)
while True:
if self.initializing:
self.initializing = False
self.publish(dict(method='initialized'))
message = aes.decrypt(rpc_socket.recv(), settings.KEY)
ob = json.loads(message)
try:
res = getattr(self, ob.get("method"))(ob)
st = json.dumps(res, cls=ComplexEncoder)
rpc_socket.send(aes.encrypt(st, settings.KEY))
except Exception as e:
self.logger.exception(e)
gevent.sleep(.1)
def hello(self, obj):
return self.json()
def get_sensor(self, index):
for sensor in self.sensors:
if sensor.index == index: return sensor
return False
def get_output(self, index):
for output in self.outputs:
if output.index == index: return output
return False
def get_input(self, index):
for input in self.inputs:
if input.index == index: return input
return False
def get_sensor_values(self, ob):
res = {}
for sensor in self.sensors:
res[sensor.id] = sensor.json()
return res
def get_output_values(self):
res = {}
for output in self.outputs:
res[ouput.id] = output.json()
return res
def set_output_state(self, ob):
output = self.get_output(ob.get('index'))
if output:
self.logger.info("%s: turning %s to %s index: %s" % (self.name, ob.get('type'), ob.get('state'), output.index))
output.set_state(ob.get('state'))
return dict(state=output.current_state)
def json(self, ob=None):
return dict(
name=self.name,
sensors=[s.json() for s in self.sensors],
outputs=[o.json() for o in self.outputs],
inputs=[i.json() for i in self.inputs],
triggers=[t.json() for t in self.triggers],
repeaters=[r.json() for r in self.repeaters],
clocks=[c.json() for c in self.clocks],
cls=self.__class__.__name__
)
def __conform__(self, protocol):
return json.dumps(self.json(), cls=ComplexEncoder)
def displayDeviceInfo(self):pass
#Event Handler Callback Functions
def inferfaceKitAttached(self, e):
attached = e.device
self.logger.info("InterfaceKit %i Attached!" % (attached.getSerialNum()))
def interfaceKitDetached(self, e):
detached = e.device
self.logger.info("InterfaceKit %i Detached!" % (detached.getSerialNum()))
def interfaceKitError(self, e):
try:
if e.eCode not in (36866,):
source = e.device
self.logger.info("InterfaceKit %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
self.logger.exception(e)
def interfaceKitInputChanged(self, e):
input = self.get_input(e.index)
if not input: return
val = input.do_conversion(e.value)
ob = input.json()
self.publish(ob)
self.logger.info("%s Input: %s" % (input.display, val))
def interfaceKitSensorChanged(self, e):
sensor = self.get_sensor(e.index)
if not sensor: return
val = sensor.do_conversion(float(e.value)) if sensor else 0
ob = sensor.json()
self.publish(ob)
self.logger.info("%s Sensor: %s" % (sensor.display, val))
def interfaceKitOutputChanged(self, e):
output = self.get_output(e.index)
if not output: return
output.current_state = e.state
ob = output.json()
self.publish(ob)
self.logger.info("%s Output: %s" % (output.display, output.current_state))
def run(self):
if LIVE: self.init_kit()
while True: gevent.sleep(.1)
def init_kit(self):
try:
self.interface_kit.setOnAttachHandler(self.inferfaceKitAttached)
self.interface_kit.setOnDetachHandler(self.interfaceKitDetached)
self.interface_kit.setOnErrorhandler(self.interfaceKitError)
self.interface_kit.setOnInputChangeHandler(self.interfaceKitInputChanged)
self.interface_kit.setOnOutputChangeHandler(self.interfaceKitOutputChanged)
self.interface_kit.setOnSensorChangeHandler(self.interfaceKitSensorChanged)
except PhidgetException as e:
self.logger.exception(e)
self.logger.info("Opening phidget object....")
try:
self.interface_kit.openPhidget()
except PhidgetException as e:
self.logger.exception(e)
self.logger.info("Waiting for attach....")
try:
self.interface_kit.waitForAttach(10000)
except PhidgetException as e:
self.logger.exception(e)
try:
self.interface_kit.closePhidget()
except PhidgetException as e:
self.logger.exception(e)
self.logger.info("Exiting....")
exit(1)
self.logger.info("Exiting....")
else:
self.displayDeviceInfo()
self.logger.info("Initializing Sensors")
for i in range(self.interface_kit.getSensorCount()):
try:
sensor = self.get_sensor(i)
if sensor:
self.logger.info("Setting Up: %s" % sensor.display)
self.logger.info("Change: %s" % sensor.change)
self.logger.info("Data Rate: %s" % sensor.data_rate)
self.interface_kit.setSensorChangeTrigger(i, sensor.change)
self.interface_kit.setDataRate(i, sensor.data_rate)
except PhidgetException as e:
self.logger.exception(e)
def setup_phidgets():
global interfaceKits
interfaceKits = InterfaceKits()
"Print Creating phidget manager"
try:
manager = Manager()
except RuntimeError as e:
output("Runtime Exception: %s" % e.details)
output("Exiting....")
exit(1)
try:
manager.setOnAttachHandler(ManagerDeviceAttached)
manager.setOnDetachHandler(ManagerDeviceDetached)
manager.setOnErrorHandler(ManagerError)
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
exit(1)
output("Opening phidget manager....")
logging.info("Opening phidget manager....")
try:
manager.openManager()
#manager.openRemote("hydropi","hydropi")
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
logging.error("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
logging.error("Exiting....")
exit(1)
# Wait a moment for devices to attache......
output("\nWaiting one sec for devices to attach....\n\n")
logging.info("Waiting one sec for devices to attach....")
time.sleep(1)
output("Phidget manager opened.")
attachedDevices = manager.getAttachedDevices()
for attachedDevice in attachedDevices:
output("Found %30s - SN %10d" % (attachedDevice.getDeviceName(), attachedDevice.getSerialNum()))
if attachedDevice.getDeviceClass() == PhidgetClass.INTERFACEKIT:
output(" %s/%d is an InterfaceKit" % ( attachedDevice.getDeviceName(),attachedDevice.getSerialNum()))
#Create an interfacekit object
try:
newInterfaceKit = InterfaceKit()
except RuntimeError as e:
output("Runtime Exception: %s" % e.details)
output("Exiting....")
exit(1)
output(" Opening...")
try:
newInterfaceKit.openPhidget()
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
output(" Setting handlers...")
try:
newInterfaceKit.setOnAttachHandler(interfaceKitAttached)
newInterfaceKit.setOnDetachHandler(interfaceKitDetached)
newInterfaceKit.setOnErrorhandler(interfaceKitError)
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
exit(1)
output(" Attaching...")
try:
newInterfaceKit.waitForAttach(5000)
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
try:
newInterfaceKit.closePhidget()
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
output("Exiting....")
exit(1)
output("Exiting....")
exit(1)
output(" Setting the data rate for each sensor index to 1000ms....")
for i in range(newInterfaceKit.getSensorCount()):
try:
newInterfaceKit.setDataRate(i, 1000)
except PhidgetException as e:
output("Phidget Exception %i: %s" % (e.code, e.details))
interfaceKits.kitList.append(newInterfaceKit)
display_device_info(manager)
return manager
kit.waitForAttach(2000)
s = dict()
s['sens'] = np.zeros((1, 2))
s['start_time'] = time.time()
sec_of_dat = 600
f_s = 60
err_ind = []
for i in range(sec_of_dat * f_s):
s['tic'] = time.time()
sensdat = np.zeros((1, 2))
try:
sensdat[0, 0] = kit.getSensorValue(0) / 1000.
sensdat[0, 1] = kit.getSensorValue(1) / 1000.
except:
print(time.time() - s['start_time'], i)
print(kit.isAttached())
err_ind.extend([i])
try:
print(kit.getSensorRawValue(2), kit.getSensorValue(2))
except:
print('novalue')
s['sens'] = np.vstack((s['sens'], sensdat))
left_over_time = np.max([0, 1000 / 60. - (time.time() - s['tic'])])
time.sleep(left_over_time / 1000.)
kit.closePhidget()
plt.plot(np.array(err_ind) / float(f_s))
class Phidgets:
def __init__(self):
self.V1 = 0.0
self.V2list = [0,0,0,0,0,0,0] #lista dei valori associati alle porte analogiche, corrispondenza porta analogica posizione nella lista
self.running = True
def ponteDiWheatstone(self):
R1 = 1000.0#1KOhm
R2 = 1000.0#1KOhm
R3 = 1000.0#1KOhm
Vs = 5.0
for pos, v in enumerate(self.V2list):
if v==0:
continue
Vm = v-self.V1 #ingresso differenziale
print Vm
#formula per il calcolo della resistenza
p1 = R3/(R1+R3) + (Vm/Vs)
p2 = 1 - p1
Rx = R2*(p1/p2);
#
date = datetime.now().strftime('%Y-%m-%d')
time = datetime.now().strftime('%H:%M:%S')
self.monitoring.insertValue(Rx, pos+1, date,time)
#
print ("la resistenza sull'input %d vale %f: " % (pos+1, Rx))
def partitoreDiTensione(self, val):
if val != 1:
r1 = 1000
Vref = 12 #5V tensione applicata al partitore
V2 = (5.0/1023.0)*val #tensione letta ai capi della resistenza
r2 = r1*V2/(Vref-V2)
print ("la resistenza vale %f: " % r2)
def interfaceKitSensorChanged(self, e):
source = e.device
if e.value == 1:#1 indica che non sta nulla collegato e resetto anche il suo valore nella lista
if e.index==0:
self.V1=0
else:
self.V2list[e.index-1]=0
return
if e.index == 0:#V1 va collegato sempre sul pin 0
self.V1 = (5.0/1023.0)*e.value
print self.V1
else:
val = (5.0/1023.0)*e.value
self.V2list[e.index-1]=val #corrispondenza porta analogica posizione nella lista
print str(self.V2list)
self.ponteDiWheatstone()
#if e.value != 1:
# self.monitoring.insertPos(e.index)
#print("InterfaceKit %i: Sensor %i: %i" % (source.getSerialNum(), e.index, e.value))
def run(self):
try:
self.interfaceKit = InterfaceKit() #instanzio la classe per interfacciarmi con la scheda di acquisizione
self.monitoring = sm.SensorMonitoring() #tabella dove sono memorizzati i valori dei sensori collegati
self.monitoring.open()
self.monitoring.create()
except RuntimeError as e:
print("Runtime Exception: %s" % e.details)
print("Exiting....")
exit(1)
try:
self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChanged)
except PhidgetException as e:
print("Exiting....")
exit(1)
try:
self.interfaceKit.openPhidget()
except PhidgetException as e:
print("Exiting....")
exit(1)
try:
self.interfaceKit.waitForAttach(10000)
except PhidgetException as e:
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
exit(1)
print("Assicurarsi di aver collegato la scheda di acquisizione Phidget 1019 al PC. Exiting....")
exit(1)
else:
print "Scheda di acquisizione rilevata."
for i in range(self.interfaceKit.getSensorCount()):
try:
self.interfaceKit.setDataRate(i, 4)
except PhidgetException as e:
pass
def close(self):
self.running = False
self.monitoring.close()
print("Closing...")
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Done.")
exit(0)
class force_glove:
def __init__(self, log_file):
self.interfaceKit = InterfaceKit()
self.log_file = log_file
try:
self.interfaceKit.setOnAttachHandler(self.interfaceKitAttached)
self.interfaceKit.setOnDetachHandler(self.interfaceKitDetached)
self.interfaceKit.setOnErrorhandler(self.interfaceKitError)
self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChanged)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Turning on glove....")
try:
self.interfaceKit.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for glove to attach....")
try:
self.interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
else:
print "Glove connected..."
# self.displayDeviceInfo()
return
def setSensorRates(self):
for i in range(self.interfaceKit.getSensorCount()):
try:
self.interfaceKit.setDataRate(i, 2)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
return
def closeForceGlove(self):
try:
self.interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
print("Closed force glove...")
return
# Information Display Function
#def displayDeviceInfo(self):
# print("Glove " + self.interfaceKit.getDeviceName() + " found")
# print("Number of Sensor Inputs: %i" % (self.interfaceKit.getSensorCount()))
# Event Handler Callback Functions
def interfaceKitAttached(self, e):
attached = e.device
print("InterfaceKit %i Attached!" % (attached.getSerialNum()))
def interfaceKitDetached(self, e):
detached = e.device
print("InterfaceKit %i Detached!" % (detached.getSerialNum()))
def interfaceKitError(self, e):
try:
source = e.device
print("InterfaceKit %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
def interfaceKitSensorChanged(self, e):
force_data = "%i,%i" % (e.index, e.value)
self.write_log(force_data)
print("Sensor %i: %i" % (e.index, e.value))
def write_log(self, glove_data):
if glove_data is not None:
to_log = ('%f,%s\r\n') % (time.time(), glove_data)
if not self.log_file.closed:
self.log_file.write(to_log)
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
if not interfaceKitLCD.isAttachedToServer():
sleep(2)
print('interfaceKitLCD attached to server: %s' % interfaceKitLCD.isAttachedToServer())
#Wait for the device to attach
try:
interfaceKitLCD.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
interfaceKitLCD.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
#textLCD.setBacklight(True)
#textLCD.setBrightness(128)
print("lcd setup complete, ready for use")
context = zmq.Context()
#lcd_receiver = context.socket(zmq.PULL)
try:
interfaceKit.openPhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Waiting for InterfaceKit to attach....")
try:
interfaceKit.waitForAttach(10000)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
print("Press Enter to quit....")
chr = sys.stdin.read(1)
print("Closing...")
try:
interfaceKit.closePhidget()
