Python Devices.InterfaceKit类代码示例

class tosRelayControl:
    """
    This class handles polling and controlling the Phidgets InterfaceKit 0/0/4. It requires the PhidgetLinux libraries and the PhidgetPython libraries.
    """

    ifkit = None
    logger = None

    def __init__(self):
        """
        Instantiate the InterfaceKit object and open it.
        """
        self.logger = tosLogger
        
        self.ifkit = InterfaceKit()

        # open ifkit
        try:
            self.ifkit.openPhidget()
        except PhidgetException, e:
            self.logger.log(self, 3, "Phidget Exception %i: %s" % (e.code, e.message))
            exit(1)

        # wait for attach
        try:
            self.ifkit.waitForAttach(10000)
        except PhidgetException, e:
            self.logger.log(self, 3, "Phidget Exception %i: %s" % (e.code, e.message))

class phidget:
    def __init__(self, id, port):
        self.id = id
        self.port = port
        self.serial_numbers = (262305, # 4-port, shelf 6
                               262295, # 4-port, shelf 6
                               318471, # 8-port, shelf 2
                               312226, # 8-port, shelf 4
                               259764, # 4-port, shelf 8
                               319749, # 8-port, shelf 10
                               259763, # 4-port, shelf 6
                               )
        self.serial_num = self.serial_numbers[id]
        self.lockfile = "/var/run/lock/phidget-%s.lock" %self.id
        self.lock_fp = open(self.lockfile, "w")
        self.lock_fd = self.lock_fp.fileno()
        fcntl.lockf(self.lock_fd, fcntl.LOCK_EX)
        if debug:
            print "[%.2f] Aquired lock for Phidget %s" %(time.time(), self.id)

        try:
            self.device = InterfaceKit()	
        except RuntimeError as e:
            print("Runtime Error: %s" % e.message)
    
        try:
            self.device.openPhidget(serial=self.serial_num)
        except PhidgetException as e:
            print ("Phidget Exception %i: %s" % (e.code, e.detail))
            fcntl.lockf(self.lock_fd, fcntl.LOCK_UN)
            exit(1)

        self.device.waitForAttach(10000)

        #print ("Phidget %d attached!" % (self.device.getSerialNum()))
        #print ("Phidget has %d inputs, %d outputs, %d sensors"
        #       %(self.device.getInputCount(), self.device.getOutputCount(), self.device.getSensorCount()))

    def close(self):
        self.device.closePhidget()
        fcntl.lockf(self.lock_fd, fcntl.LOCK_UN)
        if debug:
            print "[%.2f] Released lock for Phidget %s" %(time.time(), self.id)

    def on(self):
        self.device.setOutputState(self.port, 1)

    def off(self):
        self.device.setOutputState(self.port, 0)

    def cmd(self, cmd):
        if cmd == 'on':
            self.on()
        if cmd == 'off':
            self.off()

class SensorThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        # Create
        try:
            print "Setting up sensor interface"
            self.device = InterfaceKit()	
        except RuntimeError as e:
            print("Runtime Error: %s" % e.message)
         
        # Open
        try:
            # Hook our function above into the device object
            self.device.setOnSensorChangeHandler(sensorChanged)
            self.device.openPhidget()
        except PhidgetException as e:
            print ("Phidget Exception %i: %s" % (e.code, e.detail))		
            exit(1)

    def run(self):
        self.running = True
        print "Sensors> Waiting for attach"
        try:
            self.device.setOnAttachHandler(AttachHandler)
        except PhidgetException as e:
            print "Phidget Exception %i" % (e.code)		
        pass
    
    def stop(self):
        self.running = False
        self.device.closePhidget()

def connect_phidget():
	try:
  		log_info('creating the interface kit')
  		device = InterfaceKit()
	except RuntimeError as e:
  		log_error("Error when trying to create the device: %s" % e.message)

	#This connects to the device.
	try:
 		#print 'connecting to the device!'
  		device.openPhidget()
	except PhidgetException as e:
 		log_warning("Exception when trying to connect %i: %s" % (e.code, e.detail))		
  		exit(1)

	return device

 def __init__(self):
     rospy.init_node('interface_kit', anonymous=True)
     self.name = rospy.get_param('~name', '')
     self.serial = rospy.get_param('~serial_number', -1)
     
     if self.serial == -1:
         rospy.logwarn('No serial number specified. This node will connect to the first interface kit attached.')
     self.interface_kit = InterfaceKit()

class PhidgetTextLCD(object):
  """
  A class modelled after a Phidget InterfaceKit with an integrated LCD.
  It contains a list of objects, which are subclasses of Sensor object.

  Attributes:
      analog_sensors: a list containing objects of one of subclasses of Sensor
      data_dir: a string of directory path to save sensor reading data in
  """

  def __init__(self, analog_sensors, data_dir):
    """Initializes the members."""
    self.__interfaceKit = InterfaceKit()
    self.__textLCD = TextLCD()

    self.__data_dir = data_dir

    # instantiate classes according to actual sensor port configuration
    self.sensors = []
    for sensor in analog_sensors:
      a_sensor = self.__Factory(sensor)
      self.sensors.append(a_sensor)

    try:
      # Interface Kit
      self.__interfaceKit.openPhidget()
      self.__interfaceKit.waitForAttach(10000)
      print "%s (serial: %d) attached!" % (
        self.__interfaceKit.getDeviceName(), self.__interfaceKit.getSerialNum())

      # get initial value from each sensor
      i = 0
      for sensor in self.sensors:
        #print sensor.product_name
        #print sensor.value
        sensor.value = self.__interfaceKit.getSensorValue(i)
        i += 1

      self.__interfaceKit.setOnSensorChangeHandler(self.__SensorChanged)

      # Text LCD
      self.__textLCD.openPhidget()
      self.__textLCD.waitForAttach(10000)
      print "%s attached!" % (self.__textLCD.getDeviceName())

      self.__textLCD.setCursorBlink(False)

    except PhidgetException, e:
      print "Phidget Exception %i: %s" % (e.code, e.message)
      sys.exit(1)

class IfkAgent(object):
    def __init__(self, queue, serial):
        self.serial=serial
        self._q=queue
        self._ic=0 ## digital input count
        self._oc=0 ## digital output count
        self._sc=0 ## sensor input count
        
        try:
            self.ifk=InterfaceKit()
            self._setHooks()
            self.ifk.openPhidget(int(serial))
            

        except Exception,e:
            print "*** Exception: ",e
            w="Can't instantiate a Phidgets.Devices.InterfaceKit"
            Bus.publish(self, "%log", "warning", w)

def start_sensors_for_changes():
	#Create and connect to the device using the InterfaceKit() method.
	#This method depends on the device that we are using. For us, it
	#happens to be the interfacekit.
	try:
  		print 'creating the interface kit'
  		device = InterfaceKit()
	except RuntimeError as e:
  		print("Error when trying to create the device: %s" % e.message)

	#This connects to the device.
	try:
  		print 'connecting to the device!'
  		device.openPhidget()
	except PhidgetException as e:
  		print ("Exception when trying to connect %i: %s" % (e.code, e.detail))
  		exit(1)

	device.setOnSensorChangeHandler(sensorChanged)

 def init(self):
     """ Init 
     """
     try:
         self.ikit = InterfaceKit()
         
         self.ikit.setOnAttachHandler(self.inferfaceKitAttached)
         self.ikit.setOnDetachHandler(self.interfaceKitDetached)
         self.ikit.setOnErrorhandler(self.interfaceKitError)
         self.ikit.setOnInputChangeHandler(self.interfaceKitInputChanged)
         self.ikit.setOnOutputChangeHandler(self.interfaceKitOutputChanged)
         self.ikit.setOnSensorChangeHandler(self.interfaceKitSensorChanged)
     except Exception,e:
         pass

 def __init__(self):
     threading.Thread.__init__(self)
     # Create
     try:
         print "Setting up sensor interface"
         self.device = InterfaceKit()	
     except RuntimeError as e:
         print("Runtime Error: %s" % e.message)
      
     # Open
     try:
         # Hook our function above into the device object
         self.device.setOnSensorChangeHandler(sensorChanged)
         self.device.openPhidget()
     except PhidgetException as e:
         print ("Phidget Exception %i: %s" % (e.code, e.detail))		
         exit(1)

def init():
        notifo = Notifo(user="pcondosta", secret="xc53e5cdc470b9adb5165adcd4aeb597549136d7c")
        db=MySQLdb.connect(host="localhost",user="pete",passwd="",db="security")
        c=db.cursor()
        interfaceKit = InterfaceKit()
        interfaceKit.openPhidget()
        interfaceKit.waitForAttach(10000)
        security_state = interfaceKit.getInputState(0)
        sec_state(security_state)
        FD,BSDR,BSLR = getSensor()
        updateMysql(FD,"FD")
        updateMysql(BSDR,"BSDR")
        updateMysql(BSLR,"BSLR")

  def __init__(self, analog_sensors, data_dir):
    """Initializes the members."""
    self.__interfaceKit = InterfaceKit()
    self.__textLCD = TextLCD()

    self.__data_dir = data_dir

    # instantiate classes according to actual sensor port configuration
    self.sensors = []
    for sensor in analog_sensors:
      a_sensor = self.__Factory(sensor)
      self.sensors.append(a_sensor)

    try:
      # Interface Kit
      self.__interfaceKit.openPhidget()
      self.__interfaceKit.waitForAttach(10000)
      print "%s (serial: %d) attached!" % (
        self.__interfaceKit.getDeviceName(), self.__interfaceKit.getSerialNum())

      # get initial value from each sensor
      i = 0
      for sensor in self.sensors:
        #print sensor.product_name
        #print sensor.value
        sensor.value = self.__interfaceKit.getSensorValue(i)
        i += 1

      self.__interfaceKit.setOnSensorChangeHandler(self.__SensorChanged)

      # Text LCD
      self.__textLCD.openPhidget()
      self.__textLCD.waitForAttach(10000)
      print "%s attached!" % (self.__textLCD.getDeviceName())

      self.__textLCD.setCursorBlink(False)

    except PhidgetException, e:
      print "Phidget Exception %i: %s" % (e.code, e.message)
      sys.exit(1)

    def __init__(self):
        try:
            self.device = InterfaceKit()
        except RuntimeError as e:
            print("Runtime Error: %s" % e.message)

        self.height = 0
        self.vel = 0
        self.last_hit_time = 0
        self.lock = Lock()

        num = [0.0181,0.0543,0.0543,0.0181]
        den = [1,-1.76,1.1829,-0.2781]

        self.vzfilter = IIRfilter(num,den)

        try:
            self.device.setOnAttachHandler(self.AttachHandler)
            self.device.setOnDetachHandler(self.DetachHandler)
            self.device.openPhidget()
            self.device.setOnSensorChangeHandler(self.sensorChanged)
        except PhidgetException as e:
            self.LocalErrorCatcher(e)

        for i in range(len(codeInfo.Repeat)):
            if i > 0:
                printStr += ", "
            printStr += str(codeInfo.Repeat[i])
        printStr += " }"
        
        message("Repeat: %s" % (printStr))
    else:
        message("Repeat: None")
    
    message("MinRepeat: %d\nToggle Mask: %s\nCarrier Frequency: %d\nDuty Cycle: %d" % (codeInfo.MinRepeat, codeInfo.ToggleMask.toString(), codeInfo.CarrierFrequency, codeInfo.DutyCycle))
    message("----------------------------------------------------")


try:
    interfaceKit = InterfaceKit()
    message( "Setting up interface", interfaceKit)
    ir = IR()
except RuntimeError as e:
    print("Runtime Error: %s" % e.message)

try:
    try:
        message( "Opening IR Device 121774")
        ir.openPhidget(121774)
        message( "Waiting for attachment...")
        ir.waitForAttach(10000)
        message("Device ready.")
        ir.setOnAttachHandler(irAttached)
        ir.setOnDetachHandler(irDetached)
        ir.setOnErrorhandler(irError)

def main():
	parser = argparse.ArgumentParser(description='read sensor values from a Phidgets device')
	
	group = parser.add_mutually_exclusive_group(required=True)
	
	group.add_argument('-d', '--digital', metavar='<input id>', type=int, help='read from a digital input')
	group.add_argument('-a', '--analog', metavar='<sensor id>', type=int, help='read from an analog sensor')
	
	parser.add_argument('-t', '--temperature-sensor', action='store_const', const=True, default=False, help='device is a temperature sensor, output in degrees celcius. must be reading an analog sensor')
	parser.add_argument('-m', '--precision-light-sensor-multiplier', metavar='<multiplier>', type=float, help='\'m\' value from the underside of the precision light sensor. must be reading an analog sensor')
	parser.add_argument('-b', '--precision-light-sensor-boost', metavar='<boost>', type=float, help='\'b\' value from the underside of the precision light sensor. must be reading an analog sensor')
	cli_args = parser.parse_args()
	
	try:
		device = InterfaceKit()
	except RuntimeError as e:
		print("Runtime Error: %s" % e.message)
		exit(2)
	
	try:
		device.openPhidget()
		device.waitForAttach(1000)
		
		if cli_args.digital != None:
			if cli_args.digital < device.getInputCount():
				print device.getInputState(cli_args.digital)
			else:
				parser.print_usage()
				print('%s: error: input id out of range (maximum is %d)' % (sys.argv[0], device.getInputCount()-1))
		elif cli_args.analog != None:
			if cli_args.analog < device.getSensorCount():
				if cli_args.temperature_sensor == True:
					print (float(device.getSensorValue(cli_args.analog)) * 0.2222) - 61.1111 
				elif (cli_args.precision_light_sensor_multiplier == None) != (cli_args.precision_light_sensor_boost == None):
					parser.print_usage()
					print('%s: error: you must supply both precision light sensor arguments')
				elif cli_args.precision_light_sensor_multiplier != None and cli_args.precision_light_sensor_boost != None:
					print (cli_args.precision_light_sensor_multiplier * float(device.getSensorValue(cli_args.analog)) + cli_args.precision_light_sensor_boost)
				else:
					print device.getSensorValue(cli_args.analog)
			else:
				parser.print_usage()
				print('%s: error: sensor id out of range (maximum is %d)' % (sys.argv[0], device.getSensorCount()-1))
		device.closePhidget()
	except PhidgetException as e:
		print("Phidget Exception %i: %s" % (e.code, e.details))
		try:
			device.closePhidget()
		except PhidgetException as e:
			print("Phidget Exception %i: %s" % (e.code, e.details))
		print("Exiting...")
		exit(1)
	exit(0)