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]))
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