def AttachInterfaceKit(databasepath, serialNumber): def inputChangeHandler(event): conn = sqlite3.connect(databasepath) conn.execute( "INSERT INTO INTERFACEKIT_INPUTCHANGE VALUES(NULL, DateTime('now'), ?, ?, ?)", (event.device.getSerialNum(), event.index, event.state)) conn.commit() conn.close() def outputChangeHandler(event): conn = sqlite3.connect(databasepath) conn.execute( "INSERT INTO INTERFACEKIT_OUTPUTCHANGE VALUES(NULL, DateTime('now'), ?, ?, ?)", (event.device.getSerialNum(), event.index, event.state)) conn.commit() conn.close() def sensorChangeHandler(event): conn = sqlite3.connect(databasepath) conn.execute( "INSERT INTO INTERFACEKIT_SENSORCHANGE VALUES(NULL, DateTime('now'), ?, ?, ?)", (event.device.getSerialNum(), event.index, event.value)) conn.commit() conn.close() try: ik = InterfaceKit() ik.setOnInputChangeHandler(inputChangeHandler) ik.setOnOutputChangeHandler(outputChangeHandler) ik.setOnSensorChangeHandler(sensorChangeHandler) ik.openPhidget(serialNumber) except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting...") exit(1)
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
class cycleForever(threading.Thread): def __init__( self, behavior_setup_name, interfaceKitIPAddress, pumpIPAddress, interfaceKitPort=5001, pumpPort=100, pump_channels=["01", "02"] ): threading.Thread.__init__(self) self.setup_name = behavior_setup_name self.interfaceKitIPAddress = interfaceKitIPAddress self.interfaceKitPort = interfaceKitPort self.controller = InterfaceKit() self.controller.openRemoteIP(self.interfaceKitIPAddress, self.interfaceKitPort) self.pumpIPAddress = pumpIPAddress self.pumpPort = pumpPort self.pumpsConn = newPumpConnection(self.pumpIPAddress, self.pumpPort) self.pump_channels = pump_channels def run(self): while True: infuse = infuseFully(self.setup_name, self.controller, self.pumpsConn, pump_channels=self.pump_channels) infuse.start() infuse.join() withdraw = withdrawFully(self.setup_name, self.controller, self.pumpsConn, pump_channels=self.pump_channels) withdraw.start() withdraw.join()
class InterfaceSource(Source): def __init__(self): Source.__init__(self) try: self._device = InterfaceKit() except RuntimeError as e: print("Runtime Error: %s" % e.message) try: self._device.openPhidget() except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.detail)) self._device.setOnSensorChangeHandler(self.sensor_changed) print("Phidget: Waiting for Connection") self._device.waitForAttach(10000) self._device.setSensorChangeTrigger(0, 0) self._device.setDataRate(0, 1) print("Phidget: Connected") def sensor_changed(self, e): if self.sink is not None: self.sink([e.value])
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 __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 __init__(self, **kwargs): log.debug("Acquiring InterfaceKit") self.ik = InterfaceKit() log.debug("Registering Handlers") self.ik.setOnAttachHandler(self._onAttach) self.ik.setOnDetachHandler(self._onDetach) self.ik.setOnErrorhandler(self._onError) self.ik.setOnOutputChangeHandler(self._onOutput) self.ik.setOnInputChangeHandler(self._onInput) self.ik.setOnSensorChangeHandler(self._onSensor)
class Phidget(Relay): def __init__(self, **kwargs): super(Phidget,self).__init__(**kwargs) self.use_sqllog = True def get_port(self, port): rval = -1 if self.connect(): try: rval = self.interfaceKit.getOutputState(port) except PhidgetException as e: self.logger.error("Phidget Exception %i: %s" % (e.code, e.details)) raise e finally: self.disconnect() return rval def set_port(self, port, state): if self.connect(): try: self.interfaceKit.setOutputState(port, state) except PhidgetException as e: self.logger.error("Phidget Exception %i: %s" % (e.code, e.details)) raise e finally: self.disconnect() return True else: return False def connect(self): #Create an interfacekit object try: self.interfaceKit = InterfaceKit() self.interfaceKit.openPhidget() self.interfaceKit.waitForAttach(10000) except RuntimeError as e: self.logger.error("Runtime error: %s" % e.message) raise e except PhidgetException as e: self.logger.error("Phidget Exception %i: %s" % (e.code, e.details)) try: self.interfaceKit.closePhidget() except PhidgetException as e: self.logger.error("Phidget Exception %i: %s" % (e.code, e.details)) raise e return True def disconnect(self): try: self.interfaceKit.closePhidget() except PhidgetException as e: self.logger.error("Phidget Exception %i: %s" % (e.code, e.details)) raise e
def __init__(self): print ("Initiating pumps") try: self.interfaceKit = InterfaceKit() except RuntimeError as e: print ("Runtime Exception a: %s" % e.details) print ("Exiting....") exit(1) try: self.interfaceKit.openPhidget() except PhidgetException as e: print ("Phidget Exception b %i: %s" % (e.code, e.details)) print ("Exiting....") exit(1) try: self.interfaceKit.waitForAttach(1000) except PhidgetException as e: print ("Phidget Exception c %i: %s" % (e.code, e.details)) raise Exception("Timeout") try: self.interfaceKit.closePhidget() except PhidgetException as e: print ("Phidget Exception d %i: %s" % (e.code, e.details)) print ("Exiting....") exit(1) self.pumplist = [] for i in range(0, 4): self.pumplist.append(onePump(self.interfaceKit, i)) print ("Pumps ready")
def _try_init(self): if all([self._data_rate, self._attach_timeout, self._sensors]): try: from Phidgets.Devices.InterfaceKit import InterfaceKit from Phidgets.PhidgetException import PhidgetException self.interface_kit = InterfaceKit() self.interface_kit.setOnAttachHandler(lambda e: self._attach(e)) self.interface_kit.setOnDetachHandler(lambda e: self._detach(e)) self.interface_kit.setOnErrorhandler(lambda e: self._error(e)) self.interface_kit.setOnSensorChangeHandler(lambda e: self._sensor_change(e)) self.interface_kit.openPhidget() self.interface_kit.waitForAttach(self._attach_timeout) for i in range(self.interface_kit.getSensorCount()): self.interface_kit.setDataRate(i, self._data_rate) logging.info("Phidget Sensor Handler Initalized") for s in self._sensors: if s.port_num is not None: s.current_data = self.interface_kit.getSensorValue(s.port_num) logging.debug("Setting Initial Value for Sensor {} to {}".format(s.port_num, s.current_data)) else: logging.warn("Cannot set Initial Value for Sensor {}".format(s.port_num)) except ImportError: self.interface_kit = None logging.error('Phidget Python Module not found. Did you install python-phidget?') except PhidgetException as e: self.interface_kit = None logging.error("Could not Initalize Phidget Kit: {}".format(e.details))
def __init__(self): try: self.interfaceKit = InterfaceKit() except RuntimeError as e: print("Runtime Exception: %s" % e.details) exit(1) print("Connecting to Phidget.") try: self.interfaceKit.openPhidget() except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) exit(1) print("Connection opened.") try: self.interfaceKit.waitForAttach(10000) except PhidgetException as e: try: self.interfaceKit.closePhidget() except PhidgetException as e: exit(1) exit(1) print("Attached to phidget interface.")
def __init__(self, name, *args, **kwargs): self.name = name self.initializing = True if LIVE: self.interface_kit = InterfaceKit() self.manager = PubSub(self, pub_port=settings.NODE_PUB, sub_port=settings.NODE_SUB, sub_filter=self.name) self.logger = util.get_logger("%s.%s" % (self.__module__, self.__class__.__name__)) self.initialize() self.run()
def run(self): try: self.interfaceKit = InterfaceKit( ) #instanzio la classe per interfacciarmi con la scheda di acquisizione self.monitoring = sm.SensorMonitoring( ) #tabella dove sono memorizzati i valori dei sensori collegati self.monitoring.open() self.monitoring.create() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) try: self.interfaceKit.setOnSensorChangeHandler( self.interfaceKitSensorChanged) except PhidgetException as e: print("Exiting....") exit(1) try: self.interfaceKit.openPhidget() except PhidgetException as e: print("Exiting....") exit(1) try: self.interfaceKit.waitForAttach(10000) except PhidgetException as e: try: self.interfaceKit.closePhidget() except PhidgetException as e: exit(1) print( "Assicurarsi di aver collegato la scheda di acquisizione Phidget 1019 al PC. Exiting...." ) exit(1) else: print "Scheda di acquisizione rilevata." for i in range(self.interfaceKit.getSensorCount()): try: self.interfaceKit.setDataRate(i, 4) except PhidgetException as e: pass
def __init__(self): """Open InterfaceKit and Encoder devices and initialize ros node""" rospy.init_node("phidgets_node") #rospy.init_node("phidgets_node", log_level=rospy.DEBUG) # Call base class initializer, which starts a ros node with a name and log_level # It then opens and attaches Phidget device self.interfaceKit = InterfaceKit() self.encoder = Encoder() # self.bridge = Bridge() # initialize this to nan to indicate we haven't homed the location self.sled_pos = float('nan') # position of sled in millimeters self.encoder_rear_offset = 0 self.encoder_front_offset = 0 # Open the devices and wait for them to attach self._attachPhidget(self.interfaceKit, "Interface Kit") self._attachPhidget(self.encoder, "Encoder board") # self._attachPhidget(self.bridge, "Wheatstone Bridge") self.params = rospy.get_param("/phidgets") self.sled_params = self.params["sled"] self.sensor_pub = rospy.Publisher("/actuator_states/raw/", ActuatorStates, queue_size=10) self.sensor_processed_pub = rospy.Publisher("/actuator_states/proc", ActuatorStatesProcessed, queue_size=10) self.limit_sub = rospy.Subscriber("/pololu/limit_switch", LimitSwitch, self.limit_callback, queue_size=10) self.sled_is_homed = False # enable both the sled encoders self.encoder.setEnabled(self.sled_params["encoder_index"]["left"], True) self.encoder.setEnabled(self.sled_params["encoder_index"]["right"], True) # Display info of the devices self._displayDeviceInfo(self.encoder) self.displayInterfaceKitInfo()
def open_phidget(self): self.log.debug("Attempting to open phidget") self.interface = InterfaceKit() if self._serial != None: self.log.debug("Attempt to open serial: %s" % self._serial) self.interface.openPhidget(self._serial) else: self.log.debug("Attempt to open first found") self.interface.openPhidget() wait_interval = 10300 self.log.debug("Wait for attach %sms" % wait_interval) self.interface.waitForAttach(wait_interval) self.log.info("Opened phidget") return 1
def __init__( self, behavior_setup_name, interfaceKitIPAddress, pumpIPAddress, interfaceKitPort=5001, pumpPort=100, pump_channels=["01", "02"] ): threading.Thread.__init__(self) self.setup_name = behavior_setup_name self.interfaceKitIPAddress = interfaceKitIPAddress self.interfaceKitPort = interfaceKitPort self.controller = InterfaceKit() self.controller.openRemoteIP(self.interfaceKitIPAddress, self.interfaceKitPort) self.pumpIPAddress = pumpIPAddress self.pumpPort = pumpPort self.pumpsConn = newPumpConnection(self.pumpIPAddress, self.pumpPort) self.pump_channels = pump_channels
def connect(self): #Create an interfacekit object try: self.interfaceKit = InterfaceKit() self.interfaceKit.openPhidget() self.interfaceKit.waitForAttach(10000) except RuntimeError as e: self.logger.error("Runtime error: %s" % e.message) raise e except PhidgetException as e: self.logger.error("Phidget Exception %i: %s" % (e.code, e.details)) try: self.interfaceKit.closePhidget() except PhidgetException as e: self.logger.error("Phidget Exception %i: %s" % (e.code, e.details)) raise e return True
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
def __init__(self): #Create an interfacekit object try: self.interfaceKit = InterfaceKit() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) try: self.interfaceKit.openPhidget() self.interfaceKit.waitForAttach(10000) self.interfaceKit.setDataRate(self.__sensorPort, self.__sampleRate) except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) try: self.interfaceKit.closePhidget() except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") exit(1)
def __init__(self, n_sensors=2, n_inputs=1): ''' Docstring Parameters ---------- Returns ------- ''' self.n_sensors = n_sensors self.n_inputs = n_inputs self.interval = 1. / self.update_freq self.sensordat = np.zeros((n_sensors,)) self.inputdat = np.zeros((n_inputs,), dtype=np.bool) self.data = np.zeros((1,), dtype=self.dtype) self.kit = InterfaceKit() self.kit.openPhidget() self.kit.waitForAttach(2000)
def __init__(self, log_file): self.interfaceKit = InterfaceKit() self.log_file = log_file try: self.interfaceKit.setOnAttachHandler(self.interfaceKitAttached) self.interfaceKit.setOnDetachHandler(self.interfaceKitDetached) self.interfaceKit.setOnErrorhandler(self.interfaceKitError) self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChanged) except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") exit(1) print("Turning on glove....") try: self.interfaceKit.openPhidget() except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") exit(1) print("Waiting for glove to attach....") try: self.interfaceKit.waitForAttach(10000) except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) try: self.interfaceKit.closePhidget() except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") exit(1) print("Exiting....") exit(1) else: print "Glove connected..." # self.displayDeviceInfo() return
def instanciarIK (self, nroSerie): """ Método utilizado para instanciar un objeto de tipo InterfaceKit de la API de Phidgets, que permite interactuar con la placa controladora y sus puertos""" try: ik= InterfaceKit() ik.openRemoteIP(self.__ipWS, self.__puertoWS, nroSerie) ik.waitForAttach(5000) return ik except : ik.closePhidget() return None
def _try_init(self): if all([self._data_rate, self._attach_timeout, self._sensors]): try: from Phidgets.Devices.InterfaceKit import InterfaceKit from Phidgets.PhidgetException import PhidgetException self.interface_kit = InterfaceKit() self.interface_kit.setOnAttachHandler( lambda e: self._attach(e)) self.interface_kit.setOnDetachHandler( lambda e: self._detach(e)) self.interface_kit.setOnErrorhandler(lambda e: self._error(e)) self.interface_kit.setOnSensorChangeHandler( lambda e: self._sensor_change(e)) self.interface_kit.openPhidget() self.interface_kit.waitForAttach(self._attach_timeout) for i in range(self.interface_kit.getSensorCount()): self.interface_kit.setDataRate(i, self._data_rate) logging.info("Phidget Sensor Handler Initalized") for s in self._sensors: if s.port_num is not None: s.current_data = self.interface_kit.getSensorValue( s.port_num) logging.debug( "Setting Initial Value for Sensor {} to {}".format( s.port_num, s.current_data)) else: logging.warn( "Cannot set Initial Value for Sensor {}".format( s.port_num)) except ImportError: self.interface_kit = None logging.error( 'Phidget Python Module not found. Did you install python-phidget?' ) except PhidgetException as e: self.interface_kit = None logging.error("Could not Initalize Phidget Kit: {}".format( e.details))
class cycleFor(threading.Thread): def __init__( self, numCycles, behavior_setup_name, interfaceKitIPAddress, pumpIPAddress, interfaceKitPort=5001, primeForBehavior=True, pumpPort=100, pump_channels=["01", "02"] ): threading.Thread.__init__(self) self.controller = InterfaceKit() self.controller.openRemoteIP(interfaceKitIPAddress, interfaceKitPort) self.pumpsConn = newPumpConnection(pumpIPAddress, pumpPort) self.numCycles = numCycles self.behavior_setup_name = behavior_setup_name self.interfaceKitIPAddress = interfaceKitIPAddress self.pumpIPAddress = pumpIPAddress self.interfaceKitPort = interfaceKitPort self.primeForBehavior = primeForBehavior self.pumpPort = pumpPort self.pump_channels = pump_channels def run(self): #infuse fully then withdraw fully for numCycles for i in xrange(self.numCycles): infuse = infuseFully(self.behavior_setup_name, self.controller, self.pumpsConn, pump_channels=self.pump_channels) infuse.start() infuse.join() withdraw = withdrawFully(self.behavior_setup_name, self.controller, self.pumpsConn, pump_channels=self.pump_channels) withdraw.start() withdraw.join() if self.primeForBehavior: prime = primeForBehaviorSession(self.behavior_setup_name, self.controller, self.pumpsConn, pump_channels=self.pump_channels) prime.start() prime.join() self.pumpsConn.close()
def grabInterfaceKit(): try: interface_kit = InterfaceKit() interface_kit.openPhidget() interface_kit.waitForAttach(0) except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) try: interface_kit.closePhidget() except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") exit(1) print("Exiting....") exit(1) return interface_kit
def __init__( self, numCycles, behavior_setup_name, interfaceKitIPAddress, pumpIPAddress, interfaceKitPort=5001, primeForBehavior=True, pumpPort=100, pump_channels=["01", "02"] ): threading.Thread.__init__(self) self.controller = InterfaceKit() self.controller.openRemoteIP(interfaceKitIPAddress, interfaceKitPort) self.pumpsConn = newPumpConnection(pumpIPAddress, pumpPort) self.numCycles = numCycles self.behavior_setup_name = behavior_setup_name self.interfaceKitIPAddress = interfaceKitIPAddress self.pumpIPAddress = pumpIPAddress self.interfaceKitPort = interfaceKitPort self.primeForBehavior = primeForBehavior self.pumpPort = pumpPort self.pump_channels = pump_channels
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 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
def run(): kit = InterfaceKit() try: try: kit.openPhidget() kit.setOnAttachHandler(attached) kit.setOnDetachHandler(detached) if not kit.isAttached(): print "Please attach the interface kit!" raw_input() except PhidgetException as e: print ("Phidget exception %i: %s" % (e.code,e.detail)) except RuntimeError as e: print ("Runtime error: %s" % e.message) except Exception as e: print ("Unknown error: %s" % (e.message)) stop(kit)
def __init__(self, serialNumber=None, waitForAttach=1000, **kargs): self.interfaceKit = InterfaceKit() if 'remoteHost' in kargs: self.interfaceKit.openRemote(kargs['remoteHost'], serialNumber) else: self.interfaceKit.openPhidget(serialNumber) self.ratiometric = 1 if 'ratiometric' in kargs: self.ratiometric = kargs['ratiometric'] h = [ 'onAttachHandler', 'onDetachHandler', 'onErrorhandler', 'onInputChangeHandler', 'onOutputChangeHandler', 'onSensorChangeHandler' ] for event in h: self.__dict__[event] = None if event in kargs: self.__dict__[event] = kargs[event] self.interfaceKit.setOnAttachHandler(self.attached) self.interfaceKit.setOnDetachHandler(self.detached) self.interfaceKit.setOnErrorhandler(self.error) self.interfaceKit.setOnInputChangeHandler(self.inputChanged) self.interfaceKit.setOnOutputChangeHandler(self.outputChanged) self.interfaceKit.setOnSensorChangeHandler(self.sensorChanged) if waitForAttach > 0: try: self.interfaceKit.waitForAttach(waitForAttach) except PhidgetException as e: #print("Phidget Exception %i: %s" % (e.code, e.details)) try: self.interfaceKit.closePhidget() except PhidgetException as e2: pass raise e
def __init__(self): rospy.loginfo("Initializing PhidgetInterface") self.batteryVoltage = 0 self.forwardRange = 1 self.aftRange = 2 self.interfaceKit = InterfaceKit() self.forwardRangeMessage = Range() self.forwardRangeMessage.header.frame_id = 'infrared_forward' self.forwardRangeMessage.radiation_type = Range.INFRARED self.forwardRangeMessage.field_of_view = 0.018 self.forwardRangeMessage.min_range = 0.2 self.forwardRangeMessage.max_range = 0.8 self.forwardRangeMessage.range = 0.0 self.aftRangeMessage = Range() self.aftRangeMessage.header.frame_id = 'infrared_aft' self.aftRangeMessage.radiation_type = Range.INFRARED self.aftRangeMessage.field_of_view = 0.018 self.aftRangeMessage.min_range = 0.2 self.aftRangeMessage.max_range = 0.8 self.aftRangeMessage.range = 0.0 self.sensorPublisher = rospy.Publisher('bogies', Range) 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) try: self.interfaceKit.openPhidget() except PhidgetException, e: rospy.logerror("openPhidget() failed") rospy.logerror("code: %d" % e.code) rospy.logerror("message", e.message) raise
class pumpUSB: # pragma: no cover def __init__(self): print ("Initiating pumps") try: self.interfaceKit = InterfaceKit() except RuntimeError as e: print ("Runtime Exception a: %s" % e.details) print ("Exiting....") exit(1) try: self.interfaceKit.openPhidget() except PhidgetException as e: print ("Phidget Exception b %i: %s" % (e.code, e.details)) print ("Exiting....") exit(1) try: self.interfaceKit.waitForAttach(1000) except PhidgetException as e: print ("Phidget Exception c %i: %s" % (e.code, e.details)) raise Exception("Timeout") try: self.interfaceKit.closePhidget() except PhidgetException as e: print ("Phidget Exception d %i: %s" % (e.code, e.details)) print ("Exiting....") exit(1) self.pumplist = [] for i in range(0, 4): self.pumplist.append(onePump(self.interfaceKit, i)) print ("Pumps ready") def getPump(self, index): return self.pumplist[index] def getSwitch(self, index): """ yes it is the same as getPump, standard name use """ return self.pumplist[index] def close(self): self.interfaceKit.closePhidget()
def __init__(self, parent=None): super(PhidgetsEventThread, self).__init__(parent) try: self.interfaceKit = InterfaceKit() self.interfaceKit.openPhidget() self.interfaceKit.setOnAttachHandler(self.interfaceKitAttachedEvent) self.interfaceKit.setOnDetachHandler(self.interfaceKitDetachEvent) self.interfaceKit.setOnErrorhandler(self.interfaceKitErrorSlot) self.interfaceKit.setOnInputChangeHandler(self.interfaceKitInputChangedEvent) self.interfaceKit.setOnOutputChangeHandler(self.interfaceKitOutputChangedEvent) self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChangedEvent) except RuntimeError as e: print "Runtime Exception: %s" % (e.details) print "Exiting..." sys.exit(1) except PhidgetException as e: print "Phidget Exception %i: %s" % (e.code, e.details) print "Exiting..." sys.exit(1)
def run(self): try: self.interfaceKit = InterfaceKit() #instanzio la classe per interfacciarmi con la scheda di acquisizione self.monitoring = sm.SensorMonitoring() #tabella dove sono memorizzati i valori dei sensori collegati self.monitoring.open() self.monitoring.create() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) try: self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChanged) except PhidgetException as e: print("Exiting....") exit(1) try: self.interfaceKit.openPhidget() except PhidgetException as e: print("Exiting....") exit(1) try: self.interfaceKit.waitForAttach(10000) except PhidgetException as e: try: self.interfaceKit.closePhidget() except PhidgetException as e: exit(1) print("Assicurarsi di aver collegato la scheda di acquisizione Phidget 1019 al PC. Exiting....") exit(1) else: print "Scheda di acquisizione rilevata." for i in range(self.interfaceKit.getSensorCount()): try: self.interfaceKit.setDataRate(i, 4) except PhidgetException as e: pass
def __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
from ctypes import * import sys from time import sleep import zmq #Phidget specific imports from Phidgets.Phidget import PhidgetID from Phidgets.PhidgetException import PhidgetErrorCodes, PhidgetException from Phidgets.Events.Events import AttachEventArgs, DetachEventArgs, ErrorEventArgs from Phidgets.Devices.TextLCD import TextLCD, TextLCD_ScreenSize from Phidgets.Devices.InterfaceKit import InterfaceKit #Create an TextLCD object try: interfaceKitLCD = InterfaceKit() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) def InterfaceKitLCDError(e): try: source = e.device print("InterfaceKitLCD %i: Phidget Error %i: %s" % (source.getSerialNum(), e.eCode, e.description)) except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) #Connect the event handlers try:
source = e.device print("InterfaceKit %i: Output %i: %s" % (source.getSerialNum(), e.index, e.state)) if (source.getSerialNum() == SERIAL_NUM) and (e.index == RELAY): if e.state == True: # Set an alarm signal.alarm(TIMEOUT) print "Alarm set" if __name__ == "__main__": # Set the timeout alarm signal handler signal.signal(signal.SIGALRM, handler) #Create an interfacekit object try: interfaceKit = InterfaceKit() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) try: interfaceKit.setOnAttachHandler(inferfaceKitAttached) interfaceKit.setOnDetachHandler(interfaceKitDetached) interfaceKit.setOnErrorhandler(interfaceKitError) interfaceKit.setOnInputChangeHandler(interfaceKitInputChanged) interfaceKit.setOnOutputChangeHandler(interfaceKitOutputChanged) interfaceKit.setOnSensorChangeHandler(interfaceKitSensorChanged) except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....")
#Basic imports import sensMonitoring as sm from datetime import datetime #Phidget specific imports from Phidgets.PhidgetException import PhidgetException from Phidgets.Devices.InterfaceKit import InterfaceKit Wheatstone = True V1 = 0.0 V2 = 0.0 #Create an interfacekit object try: interfaceKit = InterfaceKit() monitoring = sm.SensorMonitoring( ) #tabella dove sono memorizzati i valori dei sensori collegati monitoring.open() monitoring.create() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) #Information Display Function def displayDeviceInfo(): pass
__author__ = 'Adam Stelmack' __version__ = '2.1.8' __date__ = 'May 17 2010' #Basic imports from ctypes import * import sys import random #Phidget specific imports from Phidgets.PhidgetException import PhidgetErrorCodes, PhidgetException from Phidgets.Events.Events import AttachEventArgs, DetachEventArgs, ErrorEventArgs, InputChangeEventArgs, OutputChangeEventArgs, SensorChangeEventArgs from Phidgets.Devices.InterfaceKit import InterfaceKit #Create an interfacekit object try: interfaceKit = InterfaceKit() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) #Information Display Function def displayDeviceInfo(): print("|------------|----------------------------------|--------------|------------|") print("|- Attached -|- Type -|- Serial No. -|- Version -|") print("|------------|----------------------------------|--------------|------------|") print("|- %8s -|- %30s -|- %10d -|- %8d -|" % (interfaceKit.isAttached(), interfaceKit.getDeviceName(), interfaceKit.getSerialNum(), interfaceKit.getDeviceVersion())) print("|------------|----------------------------------|--------------|------------|") print("Number of Digital Inputs: %i" % (interfaceKit.getInputCount())) print("Number of Digital Outputs: %i" % (interfaceKit.getOutputCount())) print("Number of Sensor Inputs: %i" % (interfaceKit.getSensorCount()))
class LTCPhidget(object): # TODO: can the remote specific events find a disconnected usb cable? devserial = 0 IP = "0.0.0.0" port = 0 input = {} output = {} sensor = {} callback = { 'attach': [], 'detach': [], 'error': [], 'output': [], 'input': [], 'sensor': [] } def __init__(self, **kwargs): log.debug("Acquiring InterfaceKit") self.ik = InterfaceKit() log.debug("Registering Handlers") self.ik.setOnAttachHandler(self._onAttach) self.ik.setOnDetachHandler(self._onDetach) self.ik.setOnErrorhandler(self._onError) self.ik.setOnOutputChangeHandler(self._onOutput) self.ik.setOnInputChangeHandler(self._onInput) self.ik.setOnSensorChangeHandler(self._onSensor) def start(self): log.verbose("Opening remote IP") self.ik.openRemoteIP(self.IP, self.port, self.devserial) log.debug("Remote IP opened") def close(self): log.verbose("Closing InterfaceKit") self.ik.closePhidget() log.debug("Interfac kit closed") def add_callback(self, cb, type): log.debug("Adding a {} type callback".format(type)) self.callback[type].append(cb) def remove_callback(self, cb, type): log.debug("Removing a {} type callback".format(type)) self.callback[type].remove(cb) def _genericCB(self, event, type): log.verbose("{} event received".format(type)) for cb in self.callback[type]: cb(event) for dev in self.input.itervalues(): for cb in dev.callback[type]: cb(event) for dev in self.output.itervalues(): for cb in dev.callback[type]: cb(event) for dev in self.sensor.itervalues(): for cb in dev.callback[type]: cb(event) def _onAttach(self, event): self._genericCB(event, 'attach') def _onDetach(self, event): self._genericCB(event, 'detach') def _onError(self, event): log.debug(event.description) log.verbose("{} event received".format(type)) for cb in self.callback['error']: cb(event) def _onOutput(self, event): log.verbose("Output event received") for cb in self.callback['output']: cb(event) try: for cb in self.output[event.index].callback['value']: cb(event) except KeyError: pass def _onInput(self, event): log.verbose("Input event received") for cb in self.callback['input']: cb(event) try: for cb in self.input[event.index].callback['value']: cb(event) except KeyError: pass def _onSensor(self, event): log.verbose("Sensor event received") for cb in self.callback['sensor']: cb(event) try: for cb in self.sensor[event.index].callback['value']: cb(event) except KeyError: pass
def setup_phidgets(): global interfaceKits interfaceKits = InterfaceKits() "Print Creating phidget manager" try: manager = Manager() except RuntimeError as e: output("Runtime Exception: %s" % e.details) output("Exiting....") exit(1) try: manager.setOnAttachHandler(ManagerDeviceAttached) manager.setOnDetachHandler(ManagerDeviceDetached) manager.setOnErrorHandler(ManagerError) except PhidgetException as e: output("Phidget Exception %i: %s" % (e.code, e.details)) output("Exiting....") exit(1) output("Opening phidget manager....") logging.info("Opening phidget manager....") try: manager.openManager() #manager.openRemote("hydropi","hydropi") except PhidgetException as e: output("Phidget Exception %i: %s" % (e.code, e.details)) logging.error("Phidget Exception %i: %s" % (e.code, e.details)) output("Exiting....") logging.error("Exiting....") exit(1) # Wait a moment for devices to attache...... output("\nWaiting one sec for devices to attach....\n\n") logging.info("Waiting one sec for devices to attach....") time.sleep(1) output("Phidget manager opened.") attachedDevices = manager.getAttachedDevices() for attachedDevice in attachedDevices: output("Found %30s - SN %10d" % (attachedDevice.getDeviceName(), attachedDevice.getSerialNum())) if attachedDevice.getDeviceClass() == PhidgetClass.INTERFACEKIT: output(" %s/%d is an InterfaceKit" % ( attachedDevice.getDeviceName(),attachedDevice.getSerialNum())) #Create an interfacekit object try: newInterfaceKit = InterfaceKit() except RuntimeError as e: output("Runtime Exception: %s" % e.details) output("Exiting....") exit(1) output(" Opening...") try: newInterfaceKit.openPhidget() except PhidgetException as e: output("Phidget Exception %i: %s" % (e.code, e.details)) output("Exiting....") output(" Setting handlers...") try: newInterfaceKit.setOnAttachHandler(interfaceKitAttached) newInterfaceKit.setOnDetachHandler(interfaceKitDetached) newInterfaceKit.setOnErrorhandler(interfaceKitError) except PhidgetException as e: output("Phidget Exception %i: %s" % (e.code, e.details)) output("Exiting....") exit(1) output(" Attaching...") try: newInterfaceKit.waitForAttach(5000) except PhidgetException as e: output("Phidget Exception %i: %s" % (e.code, e.details)) try: newInterfaceKit.closePhidget() except PhidgetException as e: output("Phidget Exception %i: %s" % (e.code, e.details)) output("Exiting....") exit(1) output("Exiting....") exit(1) output(" Setting the data rate for each sensor index to 1000ms....") for i in range(newInterfaceKit.getSensorCount()): try: newInterfaceKit.setDataRate(i, 1000) except PhidgetException as e: output("Phidget Exception %i: %s" % (e.code, e.details)) interfaceKits.kitList.append(newInterfaceKit) display_device_info(manager) return manager
__date__ = 'May 17 2010' #Basic imports from ctypes import * import sys import random from datetime import datetime #Phidget specific imports from Phidgets.PhidgetException import PhidgetErrorCodes, PhidgetException from Phidgets.Events.Events import AttachEventArgs, DetachEventArgs, ErrorEventArgs, InputChangeEventArgs, OutputChangeEventArgs, SensorChangeEventArgs from Phidgets.Devices.InterfaceKit import InterfaceKit from Phidgets.Devices.GPS import GPS #Create an interfacekit object try: interfaceKit = InterfaceKit() gps = GPS() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) #Information Display Function def displayDeviceInfo(): print("|------------|----------------------------------|--------------|------------|") print("|- Attached -|- Type -|- Serial No. -|- Version -|") print("|------------|----------------------------------|--------------|------------|") print("|- %8s -|- %30s -|- %10d -|- %8d -|" % (interfaceKit.isAttached(), interfaceKit.getDeviceName(), interfaceKit.getSerialNum(), interfaceKit.getDeviceVersion())) print("|------------|----------------------------------|--------------|------------|") print("Number of Digital Inputs: %i" % (interfaceKit.getInputCount())) print("Number of Digital Outputs: %i" % (interfaceKit.getOutputCount()))
from django.shortcuts import render, HttpResponse, redirect, get_object_or_404 from django.contrib.auth.forms import UserCreationForm from django.contrib.auth import authenticate, login, logout from django.contrib.auth.decorators import login_required from django.core.mail import send_mail, BadHeaderError from django.views.decorators.cache import cache_page from django.utils import timezone from django.conf import settings from .models import Plant, Photo import json from Phidgets.PhidgetException import PhidgetException from Phidgets.Devices.InterfaceKit import InterfaceKit # Create your views here. is_phidget_connected = False interfaceKit = InterfaceKit() light_val = 0 try: interfaceKit.openRemoteIP('169.254.4.87', 5001, -1, "greenspy") except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") # try: # light_val = interfaceKit.getSensorValue(0) # except PhidgetException as e: # print("Phidget Exception %i: %s" % (e.code, e.details)) def main_page(request): # Create an interface kit object return render(request, 'GreenSpy/index.html')
#Basic imports from ctypes import * import sys import random import socket #Phidget specific imports from Phidgets.PhidgetException import PhidgetErrorCodes, PhidgetException from Phidgets.Events.Events import AttachEventArgs, DetachEventArgs, ErrorEventArgs, InputChangeEventArgs, OutputChangeEventArgs, SensorChangeEventArgs from Phidgets.Devices.InterfaceKit import InterfaceKit #Create an interfacekit object try: interfaceKit = InterfaceKit() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) #Information Display Function def displayDeviceInfo(): print("|------------|----------------------------------|--------------|------------|") print("|- Attached -|- Type -|- Serial No. -|- Version -|") print("|------------|----------------------------------|--------------|------------|") print("|- %8s -|- %30s -|- %10d -|- %8d -|" % (interfaceKit.isAttached(), interfaceKit.getDeviceName(), interfaceKit.getSerialNum(), interfaceKit.getDeviceVersion())) print("|------------|----------------------------------|--------------|------------|") print("Number of Digital Inputs: %i" % (interfaceKit.getInputCount())) print("Number of Digital Outputs: %i" % (interfaceKit.getOutputCount())) print("Number of Sensor Inputs: %i" % (interfaceKit.getSensorCount()))
except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") exit(1) print("Exiting....") exit(1) advancedServo.setPosition(0, myservoposition) print("Servo initialized.") #Create an initialize an interfacekit object_______________________ print("Initialzing Interface Kit...") try: interfaceKit = InterfaceKit() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) try: interfaceKit.setOnAttachHandler(interfaceKitAttached) interfaceKit.setOnDetachHandler(interfaceKitDetached) interfaceKit.setOnErrorhandler(interfaceKitError) interfaceKit.setOnInputChangeHandler(interfaceKitInputChanged) interfaceKit.setOnOutputChangeHandler(interfaceKitOutputChanged) interfaceKit.setOnSensorChangeHandler(interfaceKitSensorChanged) except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....")
def main(): args = parseCommandLineArgs() config = getSetupInfoFromConfig() if args["add"]: saveNewSetup( args["<setupName>"][0], args["<phidgetWebServiceIPaddress>"], args["<StartechAdaptorIPaddress>"], phidget_webservice_listen_port=int(args["--phidgetPort"]), pump_telnet_listen_port=int(args["--startechPort"]), ) elif args["rm"]: for setup in args["<setupName>"]: deleteSetup(setup) elif args["config"] and args["channels"]: updateSetupField(args["<setupName>"][0], "pump_channels", [chan for chan in args["<chans>"]]) elif args["run"]: if args["cycle"]: threads = [] for setup in args["<setupName>"]: #run pump routine for each setup in its own thread pump_routine = cycleFor( int(args["-n"]), setup, config["setups"][setup]["setupIPaddr"], config["setups"][setup]["pumpIPaddr"], interfaceKitPort=config["setups"][setup]["phidget_webservice_listen_port"], primeForBehavior=args["--primePumps"], pumpPort=config["setups"][setup]["pump_telnet_listen_port"], pump_channels=config["setups"][setup]["pump_channels"] ) pump_routine.setDaemon(True) pump_routine.start() threads.append(pump_routine) print "Starting infuse/withdraw for", args["-n"], "cycles. Ctrl+c to stop pumping..." try: while threading.activeCount() > 1: #keep main thread running so it can raise KeyboardInterrupt time.sleep(1) except KeyboardInterrupt: for pump_routine in threads: #TODO make this thread safe with threading.Lock in case main thread tries to access pumpConns concurrently if pump_routine.isAlive(): for ch in pump_routine.pump_channels: ch = str(ch) pump_routine.pumpsConn.write(ch + " STP\r\n") pump_routine.pumpsConn.read_until(ch, timeout=5) pump_routine.pumpsConn.close() if args["forever"]: threads = [] for setup in args["<setupName>"]: pump_routine = cycleForever( setup, config["setups"][setup]["setupIPaddr"], config["setups"][setup]["pumpIPaddr"], interfaceKitPort=config["setups"][setup]["phidget_webservice_listen_port"], pumpPort=config["setups"][setup]["pump_telnet_listen_port"], pump_channels=config["setups"][setup]["pump_channels"] ) pump_routine.setDaemon(True) pump_routine.start() threads.append(pump_routine) print "Withdraw/Infuse cycling forever...happy cleaning. :-)" print "Protip: ctrl+c will exit the program after finishing the current cycle" try: while threading.activeCount() > 1: time.sleep(1) except KeyboardInterrupt: for pump_routine in threads: if pump_routine.isAlive(): for ch in pump_routine.pump_channels: ch = str(ch) pump_routine.pumpsConn.write(ch + " STP\r\n") pump_routine.pumpsConn.read_until(ch, timeout=5) pump_routine.pumpsConn.close() elif args["inf"]: threads = [] for setup in args["<setupName>"]: controller = InterfaceKit() controller.openRemoteIP(config["setups"][setup]["setupIPaddr"], config["setups"][setup]["phidget_webservice_listen_port"]) pumpsConn = newPumpConnection(config["setups"][setup]["pumpIPaddr"], port=config["setups"][setup]["pump_telnet_listen_port"]) time.sleep(0.2) #give time to establish connections; multiple threads need extra time pump_routine = infuseFully( setup, controller, pumpsConn, pump_channels=config["setups"][setup]["pump_channels"] ) pump_routine.setDaemon(True) pump_routine.start() threads.append(pump_routine) print "Infusing...press ctrl+c to cancel." try: while threading.activeCount() > 1: time.sleep(1) except KeyboardInterrupt: for pump_routine in threads: if pump_routine.isAlive(): for ch in pump_routine.pump_channels: ch = str(ch) pump_routine.pump_conn.write(ch + " STP\r\n") pump_routine.pump_conn.read_until(ch, timeout=5) pump_routine.pump_conn.close() elif args["wdr"]: threads = [] for setup in args["<setupName>"]: controller = InterfaceKit() controller.openRemoteIP(config["setups"][setup]["setupIPaddr"], config["setups"][setup]["phidget_webservice_listen_port"]) pumpsConn = newPumpConnection(config["setups"][setup]["pumpIPaddr"], port=config["setups"][setup]["pump_telnet_listen_port"]) time.sleep(0.2) #give time to establish connections; multiple threads need extra time pump_routine = withdrawFully( setup, controller, pumpsConn, pump_channels=config["setups"][setup]["pump_channels"] ) pump_routine.setDaemon(True) pump_routine.start() threads.append(pump_routine) print "Withdrawing...press ctrl+c to cancel." try: while threading.activeCount() > 1: time.sleep(1) except KeyboardInterrupt: for pump_routine in threads: if pump_routine.isAlive(): for ch in pump_routine.pump_channels: ch = str(ch) pump_routine.pump_conn.write(ch + " STP\r\n") pump_routine.pump_conn.read_until(ch, timeout=5) pump_routine.pump_conn.close() elif args["prime"]: threads = [] for setup in args["<setupName>"]: controller = InterfaceKit() controller.openRemoteIP(config["setups"][setup]["setupIPaddr"], config["setups"][setup]["phidget_webservice_listen_port"]) pumpsConn = newPumpConnection(config["setups"][setup]["pumpIPaddr"], port=config["setups"][setup]["pump_telnet_listen_port"]) time.sleep(0.2) #give time to establish connections; multiple threads need extra time pump_routine = primeForBehaviorSession( setup, controller, pumpsConn, pump_channels=config["setups"][setup]["pump_channels"] ) pump_routine.setDaemon(True) pump_routine.start() threads.append(pump_routine) print "Infusing 1 mL to get water flowing for a behavior session...press ctrl+c to cancel." try: while threading.activeCount() > 1: time.sleep(1) except KeyboardInterrupt: for pump_routine in threads: if pump_routine.isAlive(): for ch in pump_routine.pump_channels: ch = str(ch) pump_routine.pump_conn.write(ch + " STP\r\n") pump_routine.pump_conn.read_until(ch, timeout=5) pump_routine.pump_conn.close() else: pass
class Phidgets: def __init__(self): self.V1 = 0.0 self.V2list = [0,0,0,0,0,0,0] #lista dei valori associati alle porte analogiche, corrispondenza porta analogica posizione nella lista self.running = True def ponteDiWheatstone(self): R1 = 1000.0#1KOhm R2 = 1000.0#1KOhm R3 = 1000.0#1KOhm Vs = 5.0 for pos, v in enumerate(self.V2list): if v==0: continue Vm = v-self.V1 #ingresso differenziale print Vm #formula per il calcolo della resistenza p1 = R3/(R1+R3) + (Vm/Vs) p2 = 1 - p1 Rx = R2*(p1/p2); # date = datetime.now().strftime('%Y-%m-%d') time = datetime.now().strftime('%H:%M:%S') self.monitoring.insertValue(Rx, pos+1, date,time) # print ("la resistenza sull'input %d vale %f: " % (pos+1, Rx)) def partitoreDiTensione(self, val): if val != 1: r1 = 1000 Vref = 12 #5V tensione applicata al partitore V2 = (5.0/1023.0)*val #tensione letta ai capi della resistenza r2 = r1*V2/(Vref-V2) print ("la resistenza vale %f: " % r2) def interfaceKitSensorChanged(self, e): source = e.device if e.value == 1:#1 indica che non sta nulla collegato e resetto anche il suo valore nella lista if e.index==0: self.V1=0 else: self.V2list[e.index-1]=0 return if e.index == 0:#V1 va collegato sempre sul pin 0 self.V1 = (5.0/1023.0)*e.value print self.V1 else: val = (5.0/1023.0)*e.value self.V2list[e.index-1]=val #corrispondenza porta analogica posizione nella lista print str(self.V2list) self.ponteDiWheatstone() #if e.value != 1: # self.monitoring.insertPos(e.index) #print("InterfaceKit %i: Sensor %i: %i" % (source.getSerialNum(), e.index, e.value)) def run(self): try: self.interfaceKit = InterfaceKit() #instanzio la classe per interfacciarmi con la scheda di acquisizione self.monitoring = sm.SensorMonitoring() #tabella dove sono memorizzati i valori dei sensori collegati self.monitoring.open() self.monitoring.create() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) try: self.interfaceKit.setOnSensorChangeHandler(self.interfaceKitSensorChanged) except PhidgetException as e: print("Exiting....") exit(1) try: self.interfaceKit.openPhidget() except PhidgetException as e: print("Exiting....") exit(1) try: self.interfaceKit.waitForAttach(10000) except PhidgetException as e: try: self.interfaceKit.closePhidget() except PhidgetException as e: exit(1) print("Assicurarsi di aver collegato la scheda di acquisizione Phidget 1019 al PC. Exiting....") exit(1) else: print "Scheda di acquisizione rilevata." for i in range(self.interfaceKit.getSensorCount()): try: self.interfaceKit.setDataRate(i, 4) except PhidgetException as e: pass def close(self): self.running = False self.monitoring.close() print("Closing...") try: self.interfaceKit.closePhidget() except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") exit(1) print("Done.") exit(0)
class Pot: __sensorPort = 1 __sampleRate = 4 # Maybe too high? __potMin = 242 __potZero = 490 __potMax = 668 def __init__(self): #Create an interfacekit object try: self.interfaceKit = InterfaceKit() except RuntimeError as e: print("Runtime Exception: %s" % e.details) print("Exiting....") exit(1) try: self.interfaceKit.openPhidget() self.interfaceKit.waitForAttach(10000) self.interfaceKit.setDataRate(self.__sensorPort, self.__sampleRate) except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) try: self.interfaceKit.closePhidget() except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") exit(1) def __del__(self): try: self.interfaceKit.closePhidget() except PhidgetException as e: print("Phidget Exception %i: %s" % (e.code, e.details)) print("Exiting....") exit(1) def getRawPot(self): try: resp = self.interfaceKit.getSensorValue(self.__sensorPort) except PhidgetException as e: # suppress print (makes testing harder) #TODO restore!! resp = float('nan') #print("Skipping reading - phidget Exception %i: %s" % (e.code, e.details)) return resp #def recconect(self): def getPot(self): rawSensor = self.getRawPot() value = 0.0 if rawSensor > self.__potMax: #warnings.warn("Pot measuremens out of bounds.") return 1.0 if rawSensor < self.__potMin: #warnings.warn("Pot measuremens out of bounds.") return -1.0 if rawSensor >= self.__potZero: value = float(rawSensor - self.__potZero) / (self.__potMax - self.__potZero) else: value = float(rawSensor - self.__potZero) / (self.__potZero - self.__potMin) return value
class System(DataSourceSystem): ''' Generic DataSourceSystem interface for the Phidgets board: http://www.phidgets.com/products.php?category=0&product_id=1018_2 ''' update_freq = 1000 def __init__(self, n_sensors=2, n_inputs=1): ''' Docstring Parameters ---------- Returns ------- ''' self.n_sensors = n_sensors self.n_inputs = n_inputs self.interval = 1. / self.update_freq self.sensordat = np.zeros((n_sensors,)) self.inputdat = np.zeros((n_inputs,), dtype=np.bool) self.data = np.zeros((1,), dtype=self.dtype) self.kit = InterfaceKit() self.kit.openPhidget() self.kit.waitForAttach(2000) def start(self): ''' Docstring Parameters ---------- Returns ------- ''' self.tic = time.time() def stop(self): ''' Docstring Parameters ---------- Returns ------- ''' pass def get(self): ''' Docstring Parameters ---------- Returns ------- ''' toc = time.time() - self.tic if 0 < toc < self.interval: time.sleep(self.interval - toc) try: for i in range(self.n_sensors): self.sensordat[i] = self.kit.getSensorValue(i) / 1000. for i in range(self.n_inputs): self.inputdat[i] = self.kit.getInputState(i) except: print 'sensor_error' self.data['sensors'] = self.sensordat self.data['inputs'] = self.inputdat self.tic = time.time() return self.data def sendMsg(self, msg): ''' Docstring Parameters ---------- Returns ------- ''' pass def __del__(self): ''' Docstring Parameters ---------- Returns ------- ''' self.kit.closePhidget()