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()
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
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Exiting....")
exit(1)
else:
morse = morseEncode(message)
while(True):
send(morse)
# Wait for keypress to close the program
print("Press Enter to quit....")
chr = sys.stdin.read(1)
print("Closing...")
try:
interfaceKit.setOutputState(0, False)
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Done.")
exit(0)
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()
interfaceKit.setOutputState(7, 1)
val = interfaceKit.getSensorValue(5)
print(val)
#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:
pass
#print("Phidget Exception %i: %s" % (e.code, e.details))
print("Closing...")
interfaceKit.setOutputState(7, 0)
try:
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
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
print("Setting the data rate for each sensor index to 64ms....")
for i in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(i, 64)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Press Enter to quit....")
#### new code
#turn camera on
interfaceKit.setOutputState(0,1)
sleep(5)
temp=str(round((((interfaceKit.getSensorValue(0)) * 0.22222) - 61.11),1))
RH=str(round((((interfaceKit.getSensorValue(1)) * 0.1906 ) - 40.2 ),1))
print(temp)
print(RH)
#take a photo
time_for_filename=strftime('%Y-%m-%d-%H-%M-%S', gmtime())
photo_file_name="%s.jpg" % (time_for_filename)
photo_file_name_960="%s_960.jpg" % (time_for_filename)
photo_file_name_600="%s_600.jpg" % (time_for_filename)
print("gphoto2 --capture-image-and-download --filename %s" % (photo_file_name))
exit(2)
break
for i in range(interfaceKitHUB.getSensorCount()):
try:
#intval = interfaceKitHUB.getSensorValue(i)
#if 0 reading, don't try and convert
#if not intval:
# continue
if i >= 6:
#Sonar sensor range 0cm - 645cm
#Plugged into analog input 6 & 7 for N (forward) and S (reverse)
#turn on the sonar sensor via digital output 'i'
interfaceKitHUB.setOutputState(i,True)
#intval = interfaceKitHUB.getSensorValue(i)
#sleep(0.1) # Wait for sonar to activate
intval = interfaceKitHUB.getSensorRawValue(i) #Read sonar
print intval, i
distance_mm = (intval / 4.095 ) * 12.96 #convert raw value to mm
#Check that value is within permissable range
if distance_mm > 6450.0:
distance_mm = -1
#turn off the sonar sensor via digital output 'i'
interfaceKitHUB.setOutputState(i,False)
sleep(0.4)
#save value into array
#message.append(distance_mm)
else:
class IOTools:
def __init__(self, onRobot):
self.onRobot = onRobot
# Camera
self._openCam = False
# Motor Control
self._snMot = -1
self._openMot = False
self._attachedMot = False
self._cur = [0, 0]
# Servo
self._snSer = -1
self._openSer = False
self._attachedSer = False
self._limits = [0, 0]
# IF Kit
self._snIF = -1
self._openIF = False
self._attachedIF = False
self._inp = [0, 0, 0, 0, 0, 0, 0, 0]
self._sen = [0, 0, 0, 0, 0, 0, 0, 0]
# LEDs
self._fistTime = True
self._status = [0, 0, 0]
self._mod = [8, 1, 1]
self._rep = [-1, 5, 6]
self._val = [True, False, False]
self._ofs = [0, 0, 0]
self._updaterThread = threading.Thread(target=self.__updateLED)
self._stop = False
self._updaterThread.setDaemon(True)
self._updaterThread.start()
def destroy(self):
# LEDs
self._stop = True
if self._attachedIF:
self._interfaceKit.setOutputState(0, 0)
self._interfaceKit.setOutputState(1, 0)
self._interfaceKit.setOutputState(2, 0)
# Servo
self.servoDisengage()
# Camera
self._openCam = False
if self._openCam:
self._cap.release()
def open(self):
self.__openIF()
self.__openMot()
self.__openSer()
self.__openCam()
###################### Camera ######################
def __openCam(self):
if not os.path.exists('/dev/video0'):
return False
self._cap = cv2.VideoCapture()
if not self._cap.open(-1):
return False
self._openCam = True
def cameraGrab(self):
if self._openCam:
return self._cap.grab()
else:
return False
def cameraRead(self):
if self._openCam:
(ret, img) = self._cap.retrieve()
return img
else:
return False
def cameraSetResolution(self, sz):
if self._openCam:
sz = sz.lower()
if sz == 'low':
self._cap.set(3, 160)
self._cap.set(4, 120)
if sz == 'medium':
self._cap.set(3, 640)
self._cap.set(4, 480)
if sz == 'high':
self._cap.set(3, 800)
self._cap.set(4, 600)
if sz == 'full':
self._cap.set(3, 1280)
self._cap.set(4, 720)
def imshow(self, wnd, img):
if not self.onRobot:
if img.__class__ != numpy.ndarray:
print "imshow - invalid image"
return False
else:
cv2.imshow(wnd, img)
cv2.waitKey(5)
####################### Servo ######################
def __openSer(self):
try:
self._advancedServo = AdvancedServo()
except RuntimeError as e:
print("Servo - Runtime Exception: %s" % e.details)
return False
try:
self._advancedServo.setOnAttachHandler(self.__onAttachedSer)
self._advancedServo.setOnDetachHandler(self.__onDetachedSer)
self._advancedServo.setOnErrorhandler(self.__onErrorSer)
except PhidgetException as e:
print("Servo - Phidget Exception %i: %s" % (e.code, e.details))
return False
try:
self._advancedServo.openPhidget()
except PhidgetException as e:
print("Servo - Phidget Exception %i: %s" % (e.code, e.details))
return False
self._openSer = True
return True
def __onAttachedSer(self, e):
self._snSer = e.device.getSerialNum()
self._advancedServo.setServoType(
0, ServoTypes.PHIDGET_SERVO_HITEC_HS322HD)
self._advancedServo.setAcceleration(
0, self._advancedServo.getAccelerationMax(0))
self._advancedServo.setVelocityLimit(
0, self._advancedServo.getVelocityMax(0))
self._limits[0] = self._advancedServo.getPositionMin(0)
self._limits[1] = self._advancedServo.getPositionMax(0)
print("Servo %i Attached! Range: %f - %f" %
(self._snSer, self._limits[0], self._limits[1]))
self._attachedSer = True
def __onDetachedSer(self, e):
print("Servo %i Detached!" % (self._snSer))
self._snSer = -1
self._attachedSer = False
def __onErrorSer(self, e):
try:
source = e.device
print("Servo %i: Phidget Error %i: %s" %
(source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("Servo - Phidget Exception %i: %s" % (e.code, e.details))
def __closeSer(self):
if self._openSer == True:
self.servoDisengage()
self._advancedServo.closePhidget()
def servoEngage(self):
if self._attachedSer == True:
self._advancedServo.setEngaged(0, True)
def servoDisengage(self):
if self._attachedSer == True:
self._advancedServo.setEngaged(0, False)
def servoSet(self, pos):
if self._attachedSer == True:
self._advancedServo.setPosition(
0, min(max(pos, self._limits[0]), self._limits[1]))
############### Motor Control ######################
def __openMot(self):
try:
self._motorControl = MotorControl()
except RuntimeError as e:
print("Motor Control - Runtime Exception: %s" % e.details)
return False
try:
self._motorControl.setOnAttachHandler(self.__onAttachedMot)
self._motorControl.setOnDetachHandler(self.__onDetachedMot)
self._motorControl.setOnErrorhandler(self.__onErrorMot)
self._motorControl.setOnCurrentChangeHandler(
self.__onCurrentChangedMot)
except PhidgetException as e:
print("Motor Control - Phidget Exception %i: %s" %
(e.code, e.details))
return False
try:
self._motorControl.openPhidget()
except PhidgetException as e:
print("Motor Control - Phidget Exception %i: %s" %
(e.code, e.details))
return False
self._openMot = True
return True
def __onAttachedMot(self, e):
self._snMot = e.device.getSerialNum()
print("Motor Control %i Attached!" % (self._snMot))
self._attachedMot = True
def __onDetachedMot(self, e):
print("Motor Control %i Detached!" % (self._snMot))
self._snMot = -1
self._attachedMot = False
def __onErrorMot(self, e):
try:
source = e.device
print("Motor Control %i: Phidget Error %i: %s" %
(source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("Motor Control - Phidget Exception %i: %s" %
(e.code, e.details))
def __onCurrentChangedMot(self, e):
self._cur[e.index] = e.current
def __closeMot(self):
if self._openMot == True:
self._motorControl.closePhidget()
def setMotors(self,
speed1=0.0,
speed2=0.0,
acceleration1=100.0,
acceleration2=100.0):
if self._openMot == True:
self._motorControl.setAcceleration(0, acceleration1)
self._motorControl.setVelocity(0, speed1)
self._motorControl.setAcceleration(1, acceleration2)
self._motorControl.setVelocity(1, speed2)
############### Interface Kit ######################
def __closeIF(self):
if self._openIF == True:
self._interfaceKit.closePhidget()
def __openIF(self):
try:
self._interfaceKit = InterfaceKit()
except RuntimeError as e:
print("IF Kit - Runtime Exception: %s" % e.details)
return False
try:
self._interfaceKit.setOnAttachHandler(self.__onAttachedIF)
self._interfaceKit.setOnDetachHandler(self.__onDetachedIF)
self._interfaceKit.setOnErrorhandler(self.__onErrorIF)
self._interfaceKit.setOnInputChangeHandler(self.__onInputChangedIF)
self._interfaceKit.setOnSensorChangeHandler(
self.__onSensorChangedIF)
except PhidgetException as e:
print("IF Kit - Phidget Exception %i: %s" % (e.code, e.details))
return False
try:
self._interfaceKit.openPhidget()
except PhidgetException as e:
print("IF Kit - Phidget Exception %i: %s" % (e.code, e.details))
return False
self._openIF = True
return True
def __onAttachedIF(self, e):
self._snIF = e.device.getSerialNum()
print("InterfaceKit %i Attached!" % (self._snIF))
self._attachedIF = True
if self._fistTime:
for i in range(0, 3):
self._interfaceKit.setOutputState(0, 1)
self._interfaceKit.setOutputState(1, 1)
self._interfaceKit.setOutputState(2, 1)
time.sleep(0.1)
self._interfaceKit.setOutputState(0, 0)
self._interfaceKit.setOutputState(1, 0)
self._interfaceKit.setOutputState(2, 0)
time.sleep(0.1)
self._fistTime = False
def __onDetachedIF(self, e):
print("InterfaceKit %i Detached!" % (self._snIF))
self._snIF = -1
self._inp = [0, 0, 0, 0, 0, 0, 0, 0]
self._sen = [0, 0, 0, 0, 0, 0, 0, 0]
self._attachedIF = False
def __onErrorIF(self, e):
try:
source = e.device
print("InterfaceKit %i: Phidget Error %i: %s" %
(source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("IF Kit - Phidget Exception %i: %s" % (e.code, e.details))
def __onSensorChangedIF(self, e):
self._sen[e.index] = e.value
def __onInputChangedIF(self, e):
self._inp[e.index] = e.state
def getSensors(self):
return self._sen
def getInputs(self):
return self._inp
################ LEDs #######################
def __updateLED(self):
t = 0
while self._stop == False:
t = (t + 1) % 100
for i in range(0, 3):
self._status[i] = ((t + self._ofs[i]) % self._mod[i]
== 0) and self._val[i] and bool(
self._rep[i])
self._rep[i] = self._rep[i] - int(self._rep[i] > 0
and self._status[i])
if self._attachedIF:
self._interfaceKit.setOutputState(i, self._status[i])
time.sleep(0.15)
def __setModeLED(self, i, mode, hz=2, cnt=1, ofs=0):
if mode == 'on':
self._rep[i] = -1
self._val[i] = True
self._ofs[i] = 0
self._mod[i] = 1
if mode == 'off':
self._rep[i] = -1
self._val[i] = False
self._ofs[i] = 0
self._mod[i] = 1
if mode == 'flash':
hz = min(max(hz, 1), 100)
self._rep[i] = min(max(cnt, 1), 20)
self._val[i] = True
self._ofs[i] = min(max(ofs, 0), hz)
self._mod[i] = hz
def setStatus(self, mode, hz=2, cnt=1, ofs=0):
self.__setModeLED(1, mode, hz, cnt, ofs)
def setError(self, mode, hz=2, cnt=1, ofs=0):
self.__setModeLED(2, mode, hz, cnt, ofs)
def setSemaphor(self):
self.__setModeLED(1, 'flash', 2, 6, 0)
self.__setModeLED(2, 'flash', 2, 6, 1)
#def AttachHandler(event):
# attachedDevice = device
# serialNumber = attachedDevice.getSerialNum()
# deviceName = attachedDevice.getDeviceName()
# print("Hello to Device " + str(deviceName) + ", Serial Number: " + str(serialNumber))
try:
while not os.path.exists("/Users/u5212257/trigger"):
sleep(0.05)
print ".",
sys.stdout.flush()
print("Starting Camera_repeat_script.py")
for iii in xrange(30):
print iii+1
interfaceKit.setOutputState (7, True)
interfaceKit.setOutputState (0, True)
sleep(0.38)
interfaceKit.setOutputState (7, False)
interfaceKit.setOutputState (0, False)
sleep(0.38)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Setting the data rate for each sensor index to 16ms....")
for i in range(interfaceKit.getSensorCount()):
try:
interfaceKit.setDataRate(0, 16)
except PhidgetException as e:
try:
interfaceKit.waitForAttach(1000)
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)
try:
interfaceKit.setOutputState(relay, onoff)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Closing...")
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Done.")
exit(0)
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
#AquaIntPhidget # For use with Aquaresp.com # Author: Morten Bo Soendergaard Svendsen, fishiology.dk/comparativ.com, April 2016 import sys from Phidgets.Devices.InterfaceKit import InterfaceKit ik = InterfaceKit() ik.openPhidget() ik.waitForAttach(10000) ik.setOutputState(int(sys.argv[1]),int(sys.argv[2]))
try:
interfaceKit.waitForAttach(1000)
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)
try:
interfaceKit.setOutputState(relay, onoff)
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Closing...")
try:
interfaceKit.closePhidget()
except PhidgetException as e:
print("Phidget Exception %i: %s" % (e.code, e.details))
print("Exiting....")
exit(1)
print("Done.")
exit(0)
class IOTools:
def __init__(self, onRobot):
self.onRobot = onRobot
# Camera
self._openCam=False
# Motor Control
self._snMot=-1
self._openMot=False
self._attachedMot=False
self._cur = [0, 0]
# Servo
self._snSer=-1
self._openSer=False
self._attachedSer=False
self._limits = [0, 0]
# IF Kit
self._snIF=-1
self._openIF=False
self._attachedIF=False
self._inp = [0, 0, 0, 0, 0, 0, 0, 0]
self._sen = [0, 0, 0, 0, 0, 0, 0, 0]
# LEDs
self._fistTime = True
self._status = [0,0,0]
self._mod = [8, 1, 1]
self._rep = [-1, 5, 6]
self._val = [True, False, False]
self._ofs = [0, 0, 0]
self._updaterThread = threading.Thread(target=self.__updateLED)
self._stop = False
self._updaterThread.setDaemon(True)
self._updaterThread.start()
def destroy(self):
# LEDs
self._stop = True
if self._attachedIF:
self._interfaceKit.setOutputState(0, 0)
self._interfaceKit.setOutputState(1, 0)
self._interfaceKit.setOutputState(2, 0)
# Servo
self.servoDisengage()
# Camera
self._openCam = False
if self._openCam:
self._cap.release()
def open(self):
self.__openIF()
self.__openMot()
self.__openSer()
self.__openCam()
###################### Camera ######################
def __openCam(self):
if not os.path.exists('/dev/video0'):
return False
self._cap = cv2.VideoCapture()
if not self._cap.open(-1):
return False
self._openCam = True
def cameraGrab(self):
if self._openCam:
return self._cap.grab()
else:
return False
def cameraRead(self):
if self._openCam:
(ret, img)=self._cap.retrieve()
return img
else:
return False
def cameraSetResolution(self, sz):
"""
:rtype : object
"""
if self._openCam:
sz=sz.lower()
if sz=='low':
self._cap.set(3,160)
self._cap.set(4,120)
if sz=='medium':
self._cap.set(3,640)
self._cap.set(4,480)
if sz=='high':
self._cap.set(3,800)
self._cap.set(4,600)
if sz=='full':
self._cap.set(3,1280)
self._cap.set(4,720)
def imshow(self, wnd, img):
if not self.onRobot:
if img.__class__ != numpy.ndarray:
print "imshow - invalid image"
return False
else:
cv2.imshow(wnd,img)
cv2.waitKey(5)
####################### Servo ######################
def __openSer(self):
try:
self._advancedServo = AdvancedServo()
except RuntimeError as e:
print("Servo - Runtime Exception: %s" % e.details)
return False
try:
self._advancedServo.setOnAttachHandler(self.__onAttachedSer)
self._advancedServo.setOnDetachHandler(self.__onDetachedSer)
self._advancedServo.setOnErrorhandler(self.__onErrorSer)
except PhidgetException as e:
print("Servo - Phidget Exception %i: %s" % (e.code, e.details))
return False
try:
self._advancedServo.openPhidget()
except PhidgetException as e:
print("Servo - Phidget Exception %i: %s" % (e.code, e.details))
return False
self._openSer=True
return True
def __onAttachedSer(self,e):
self._snSer = e.device.getSerialNum()
self._advancedServo.setServoType(0, ServoTypes.PHIDGET_SERVO_HITEC_HS322HD)
self._advancedServo.setAcceleration(0, self._advancedServo.getAccelerationMax(0))
self._advancedServo.setVelocityLimit(0, self._advancedServo.getVelocityMax(0))
self._limits[0] = self._advancedServo.getPositionMin(0)
self._limits[1] = self._advancedServo.getPositionMax(0)
print("Servo %i Attached! Range: %f - %f" % (self._snSer, self._limits[0], self._limits[1]))
self._attachedSer=True
def __onDetachedSer(self,e ):
print("Servo %i Detached!" % (self._snSer))
self._snSer = -1
self._attachedSer=False
def __onErrorSer(self, e):
try:
source = e.device
print("Servo %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("Servo - Phidget Exception %i: %s" % (e.code, e.details))
def __closeSer(self):
if self._openSer==True:
self.servoDisengage()
self._advancedServo.closePhidget()
def servoEngage(self):
if self._attachedSer==True:
self._advancedServo.setEngaged(0, True)
def servoDisengage(self):
if self._attachedSer==True:
self._advancedServo.setEngaged(0, False)
def servoSet(self, pos):
if self._attachedSer==True:
self._advancedServo.setPosition(0, min(max(pos,self._limits[0]),self._limits[1]))
############### Motor Control ######################
def __openMot(self):
try:
self._motorControl = MotorControl()
except RuntimeError as e:
print("Motor Control - Runtime Exception: %s" % e.details)
return False
try:
self._motorControl.setOnAttachHandler(self.__onAttachedMot)
self._motorControl.setOnDetachHandler(self.__onDetachedMot)
self._motorControl.setOnErrorhandler(self.__onErrorMot)
self._motorControl.setOnCurrentChangeHandler(self.__onCurrentChangedMot)
except PhidgetException as e:
print("Motor Control - Phidget Exception %i: %s" % (e.code, e.details))
return False
try:
self._motorControl.openPhidget()
except PhidgetException as e:
print("Motor Control - Phidget Exception %i: %s" % (e.code, e.details))
return False
self._openMot=True
return True
def __onAttachedMot(self,e):
self._snMot = e.device.getSerialNum()
print("Motor Control %i Attached!" % (self._snMot))
self._attachedMot=True
def __onDetachedMot(self,e ):
print("Motor Control %i Detached!" % (self._snMot))
self._snMot = -1
self._attachedMot=False
def __onErrorMot(self, e):
try:
source = e.device
print("Motor Control %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("Motor Control - Phidget Exception %i: %s" % (e.code, e.details))
def __onCurrentChangedMot(self, e):
self._cur[e.index] = e.current
def __closeMot(self):
if self._openMot==True:
self._motorControl.closePhidget()
def setMotors(self, speed1=0.0, speed2=0.0, acceleration1=100.0, acceleration2=100.0 ):
if self._openMot==True:
self._motorControl.setAcceleration(0, acceleration1)
self._motorControl.setVelocity(0, speed1)
self._motorControl.setAcceleration(1, acceleration2)
self._motorControl.setVelocity(1, speed2)
############### Interface Kit ######################
def __closeIF(self):
if self._openIF==True:
self._interfaceKit.closePhidget()
def __openIF(self):
try:
self._interfaceKit = InterfaceKit()
except RuntimeError as e:
print("IF Kit - Runtime Exception: %s" % e.details)
return False
try:
self._interfaceKit.setOnAttachHandler(self.__onAttachedIF)
self._interfaceKit.setOnDetachHandler(self.__onDetachedIF)
self._interfaceKit.setOnErrorhandler(self.__onErrorIF)
self._interfaceKit.setOnInputChangeHandler(self.__onInputChangedIF)
self._interfaceKit.setOnSensorChangeHandler(self.__onSensorChangedIF)
except PhidgetException as e:
print("IF Kit - Phidget Exception %i: %s" % (e.code, e.details))
return False
try:
self._interfaceKit.openPhidget()
except PhidgetException as e:
print("IF Kit - Phidget Exception %i: %s" % (e.code, e.details))
return False
self._openIF=True
return True
def __onAttachedIF(self,e):
self._snIF = e.device.getSerialNum()
print("InterfaceKit %i Attached!" % (self._snIF))
self._attachedIF=True
if self._fistTime:
for i in range(0,3):
self._interfaceKit.setOutputState(0, 1)
self._interfaceKit.setOutputState(1, 1)
self._interfaceKit.setOutputState(2, 1)
time.sleep(0.1)
self._interfaceKit.setOutputState(0, 0)
self._interfaceKit.setOutputState(1, 0)
self._interfaceKit.setOutputState(2, 0)
time.sleep(0.1)
self._fistTime = False
def __onDetachedIF(self,e ):
print("InterfaceKit %i Detached!" % (self._snIF))
self._snIF = -1
self._inp = [0, 0, 0, 0, 0, 0, 0, 0]
self._sen = [0, 0, 0, 0, 0, 0, 0, 0]
self._attachedIF=False
def __onErrorIF(self, e):
try:
source = e.device
print("InterfaceKit %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description))
except PhidgetException as e:
print("IF Kit - Phidget Exception %i: %s" % (e.code, e.details))
def __onSensorChangedIF(self, e):
self._sen[e.index] = e.value
def __onInputChangedIF(self, e):
self._inp[e.index] = e.state
def getSensors(self):
"""
:rtype : object
"""
return self._sen;
def getInputs(self):
return self._inp;
################ LEDs #######################
def __updateLED(self):
t=0
while self._stop==False:
t=(t+1)%100
for i in range(0,3):
self._status[i]=((t+self._ofs[i])%self._mod[i]==0) and self._val[i] and bool(self._rep[i])
self._rep[i]=self._rep[i]-int(self._rep[i]>0 and self._status[i])
if self._attachedIF:
self._interfaceKit.setOutputState(i, self._status[i])
time.sleep(0.15)
def __setModeLED(self, i, mode, hz=2, cnt=1, ofs=0):
if mode=='on':
self._rep[i]=-1
self._val[i]=True
self._ofs[i]=0
self._mod[i]=1
if mode=='off':
self._rep[i]=-1
self._val[i]=False
self._ofs[i]=0
self._mod[i]=1
if mode=='flash':
hz=min(max(hz,1),100)
self._rep[i]=min(max(cnt,1),20)
self._val[i]=True
self._ofs[i]=min(max(ofs,0),hz)
self._mod[i]=hz
def setStatus(self, mode, hz=2, cnt=1, ofs=0):
self.__setModeLED(1,mode, hz, cnt, ofs)
def setError(self, mode, hz=2, cnt=1, ofs=0):
self.__setModeLED(2,mode, hz, cnt, ofs)
def setSemaphor(self):
self.__setModeLED(1,'flash', 2, 6, 0)
self.__setModeLED(2,'flash', 2, 6, 1)
relay_receiver.setsockopt(zmq.SUBSCRIBE, "") #subscribe to all messages
#relay_receiver.setsockopt(zmq.RCVTIMEO, 500) #set a timeout of 500ms for a receive operation (prevent hangs)
print("SUB socket complete on ipc://tmp/shaft.ipc")
#The MEAT goes here...
print("going into forever loop mode")
while True:
#first collect shaft movement messages...
try:
relayed = relay_receiver.recv_json()
print(relayed)
if 'down' in relayed:
interfaceKitLCD.setOutputState(0,True)
interfaceKitLCD.setOutputState(1,False)
print("going down")
sleep(int(relayed['down']))
interfaceKitLCD.setOutputState(0,False)
interfaceKitLCD.setOutputState(1,False)
elif 'up' in relayed:
interfaceKitLCD.setOutputState(0,False)
interfaceKitLCD.setOutputState(1,True)
print("going up")
sleep(int(relayed['up']))
interfaceKitLCD.setOutputState(0,False)
interfaceKitLCD.setOutputState(1,False)
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
