Python PhidgetLibrary.PhidgetLibrary类代码示例

 def __init__(self):
     """The Constructor Method for the Stepper Class
     
     Exceptions:
         RuntimeError - If current platform is not supported/phidget c dll cannot be found
     """
     Phidget.__init__(self)
     
     self.__inputChange = None
     self.__velocityChange = None
     self.__positionChange = None
     self.__currentChange = None
     
     self.__onInputChange = None
     self.__onVelocityChange = None
     self.__onPositionChange = None
     self.__onCurrentChange = None
     
     try:
         PhidgetLibrary.getDll().CPhidgetStepper_create(byref(self.handle))
     except RuntimeError:
         raise
     
     if sys.platform == 'win32':
         self.__INPUTCHANGEHANDLER = WINFUNCTYPE(c_int, c_void_p, c_void_p, c_int, c_int)
         self.__VELOCITYCHANGEHANDLER = WINFUNCTYPE(c_int, c_void_p, c_void_p, c_int, c_double)
         self.__POSITIONCHANGEHANDLER = WINFUNCTYPE(c_int, c_void_p, c_void_p, c_int, c_longlong)
         self.__CURRENTCHANGEHANDLER = WINFUNCTYPE(c_int, c_void_p, c_void_p, c_int, c_double)
     elif sys.platform == 'darwin' or sys.platform == 'linux2':
         self.__INPUTCHANGEHANDLER = CFUNCTYPE(c_int, c_void_p, c_void_p, c_int, c_int)
         self.__VELOCITYCHANGEHANDLER = CFUNCTYPE(c_int, c_void_p, c_void_p, c_int, c_double)
         self.__POSITIONCHANGEHANDLER = CFUNCTYPE(c_int, c_void_p, c_void_p, c_int, c_longlong)
         self.__CURRENTCHANGEHANDLER = CFUNCTYPE(c_int, c_void_p, c_void_p, c_int, c_double)

    def getServerAddress(self):
        """Returns the Address of a Phidget Webservice.
        
        Returns the Address of a Phidget Webservice when this Phidget was opened as remote.
        This may be an IP Address or a hostname.
        
        Returns:
            The Address of the Webservice <string>.
        
        Exceptions:
            RuntimeError - If current platform is not supported/phidget c dll cannot be found
            PhidgetException: if this Phidget was open opened as a remote Phidget.
        """
        serverAddr = c_char_p()
        port = c_int()

        try:
            result = PhidgetLibrary.getDll().CPhidget_getServerAddress(self.handle, byref(serverAddr), byref(port))
        except RuntimeError:
            raise

        if result > 0:
            raise PhidgetException(result)
        else:
            return prepOutput(serverAddr)

    def enableLogging(level, file):
        """Turns on logging in the native C Library.
        
        This is mostly usefull for debugging purposes - when an issue needs to be resolved by Phidgets Inc.
        The output is mostly low-level library information, that won't be usefull for most users.
        
        Logging may be usefull for users trying to debug their own problems, as logs can be inserted by the user using log.
        The level can be one of:
        PhidgetLogLevel.PHIDGET_LOG_VERBOSE ,
        PhidgetLogLevel.PHIDGET_LOG_INFO ,
        PhidgetLogLevel.PHIDGET_LOG_DEBUG ,
        PhidgetLogLevel.PHIDGET_LOG_WARNING ,
        PhidgetLogLevel.PHIDGET_LOG_ERROR or
        PhidgetLogLevel.PHIDGET_LOG_CRITICAL 
        
        Parameters:
            level<int>: highest level of logging that will be output, the PhidgetLogLevel object has been provided for a readable way to set this.
            file<string>: path and name of file to output to.  specify NULL to output to the console.
        
        Exceptions:
            RuntimeError - If current platform is not supported/phidget c dll cannot be found
            PhidgetException
        """
        try:
            result = PhidgetLibrary.getDll().CPhidget_enableLogging(c_int(level), c_char_p(file))
        except RuntimeError:
            raise

        if result > 0:
            raise PhidgetException(result)

    def setOnDetachHandler(self, detachHandler):
        """Sets the Detach Event Handler.
        
        The detach handler is a method that will be called when this Phidget is phisically detached from the system, and is no longer available.
        This is particularly usefull for applications when a phisical detach would be expected.
        
        Remember that many of the methods, if called on an unattached device, will throw a PhidgetException.
        This Exception can be checked to see if it was caused by a device being unattached, but a better method would be to regiter the detach handler,
        which could notify the main program logic that the device is no longer available, disable GUI controls, etc.
        
        Parameters:
            detachHandler: hook to the detachHandler callback function
        
        Exceptions:
            RuntimeError - If current platform is not supported/phidget c dll cannot be found
            PhidgetException: If this Phidget is not opened.
        """
        if detachHandler == None:
            self.__detach = None
            self.__onDetach = None
        else:
            self.__detach = detachHandler
            self.__onDetach = self.__DETACHHANDLER(self.__nativeDetachEvent)

        try:
            result = PhidgetLibrary.getDll().CPhidget_set_OnDetach_Handler(self.handle, self.__onDetach, None)
        except RuntimeError:
            self.__detach = None
            self.__onDetach = None
            raise

        if result > 0:
            raise PhidgetException(result)

    def waitForAttach(self, timeout):
        """Waits for this Phidget to become available.
        
        This method can be called after open has been called to wait for thid Phidget to become available.
        This is usefull because open is asynchronous (and thus returns immediately), and most methods will throw a PhidgetException is they are called before a device is actually ready.
        This method is synonymous with polling the isAttached method until it returns True, or using the Attach event.
        
        This method blocks for up to the timeout, at which point it will throw a PhidgetException. Otherwise, it returns when the phidget is attached and initialized.
        
        A timeout of 0 is infinite.
        
        Parameters:
            timeout<long>: Timeout in milliseconds
        
        Exceptions:
            RuntimeError - If current platform is not supported/phidget c dll cannot be found
            PhidgetException: If this Phidget is not opened.
        """

        try:
            result = PhidgetLibrary.getDll().CPhidget_waitForAttachment(self.handle, c_long(timeout))
        except RuntimeError:
            raise

        if result > 0:
            raise PhidgetException(result)

    def openRemoteIP(self, IPAddress, port, serial=-1, password=""):
        """Open this Phidget remotely using an IP Address, securely providing a password,and whether or not to connect to a specific serial number.
        
        Providing a password will open the connection securely depending on if a password is set on the host machine's webservice.
        
        If no serial number is provided, the first available Phidget will be opened. If there are two Phidgets of the same type attached to the system,
        you should specify a serial number, as there is no guarantee which Phidget will be selected by the call to open().
        
        Parameters:
            IPAddress<string>: IP Address or hostname of the Phidget Webservice
            port<int>: Port of the Phidget Webservice
            serial<int>: The serial number of the device
            password<string>: The secure password for the Phidget Webservice
        
        Exceptions:
            RuntimeError - If current platform is not supported/phidget c dll cannot be found
            PhidgetException: if the Phidget Webservice cannot be contacted
        """
        if not isinstance(serial, int):
            if password == "":
                password = serial
                serial = -1
            else:
                raise TypeError("inappropriate arguement type: serial %s" % (type(serial)))

        try:
            result = PhidgetLibrary.getDll().CPhidget_openRemoteIP(
                self.handle, c_int(serial), c_char_p(IPAddress), c_int(port), c_char_p(password)
            )
        except RuntimeError:
            raise

        if result > 0:
            raise PhidgetException(result)

    def isAttached(self):
        """Returns the attached status of this Phidget.
        
        This method returns True or False, depending on whether the Phidget is phisically plugged into the computer, initialized, and ready to use - or not.
        If a Phidget is not attached, many functions calls will fail with a PhidgetException, so either checking this function, or using the Attach and Detach events, is recommended, if a device is likely to be attached or detached during use.
        
        Returns:
            Attached Status of the Phidget <boolean>
        
        Exceptions:
            RuntimeError - If current platform is not supported/phidget c dll cannot be found
            PhidgetException: If this Phidget is not opened.
        """
        status = c_int()

        try:
            result = PhidgetLibrary.getDll().CPhidget_getDeviceStatus(self.handle, byref(status))
        except RuntimeError:
            raise

        if result > 0:
            raise PhidgetException(result)
        else:
            if status.value == 1:
                return True
            else:
                return False

 def getPositionMin(self, index):
     """Returns the minimum position that a stepper motor will accept, or return.
     
     This value uses the same usits as setTargetPosition/getTargetPosition and setCurrentPosition/getCurrentPosition.
     
     Parameters:
         index<int>: Index of the motor.
     
     Returns:
         The minimum allowable position <longlong>.
     
     Exceptions:
         RuntimeError - If current platform is not supported/phidget c dll cannot be found
         PhidgetException: If this Phidget is not opened and attached, or if the index is invalid.
     """
     positionMin = c_longlong()
     
     try:
         result = PhidgetLibrary.getDll().CPhidgetStepper_getPositionMin(self.handle, c_int(index), byref(positionMin))
     except RuntimeError:
         raise
     
     if result > 0:
         raise PhidgetException(result)
     else:
         return positionMin.value

 def setOnPositionChangeHandler(self, positionChangeHandler):
     """Sets the PositionChange event handler
     
     The position change handler is a method that will be called when the stepper position has changed.
     
     Parameters:
         positionChangeHandler: hook to the positionChangeHandler callback function.
     
     Exceptions:
         RuntimeError - If current platform is not supported/phidget c dll cannot be found
         PhidgetException
     """
     if positionChangeHandler == None:
         self.__positionChange = None
         self.__onPositionChange = None
     else:
         self.__positionChange = positionChangeHandler
         self.__onPositionChange = self.__POSITIONCHANGEHANDLER(self.__nativePositionChangeEvent)
     
     try:
         result = PhidgetLibrary.getDll().CPhidgetStepper_set_OnPositionChange_Handler(self.handle, self.__onPositionChange, None)
     except RuntimeError:
         self.__positionChange = None
         self.__onPositionChange = None
         raise
     
     if result > 0:
         raise PhidgetException(result)

 def getCurrentPosition(self, index):
     """Returns a motor's current position.
     
     This is the actual step position that the motor is at right now.
     The valid range is between getPositionMin and getPositionMax.
     
     This value is in (micro)steps. The step unit will depend on the Stepper Controller.
     For example, the Bipolar Stepper controller has an accuracy of 16th steps, so this value would be in 16th steps.
     
     Parameters:
         index<int>: Index of the motor.
     
     Returns:
         The current position of the motor <longlong>.
     
     Exceptions:
         RuntimeError - If current platform is not supported/phidget c dll cannot be found
         PhidgetException: If this Phidget is not opened and attached, or if the index is invalid.
     """
     currentPosition = c_longlong()
     
     try:
         result = PhidgetLibrary.getDll().CPhidgetStepper_getCurrentPosition(self.handle, c_int(index), byref(currentPosition))
     except RuntimeError:
         raise
     
     if result > 0:
         raise PhidgetException(result)
     else:
         return currentPosition.value

 def setCurrentPosition(self, index, value):
     """Sets a motor's current position.
     
     Use this is (re)set the current physical position of the motor to a specific position value.
     This does not move the motor, and if the motor is moving, calling this will cause it to stop moving.
     Use setTargetPosition to move the motor to a position.
     The valid range is between getPositionMin and getPositionMax.
     
     This value is in (micro)steps. The step unit will depend on the Stepper Controller.
     For example, the Bipolar Stepper controller has an accuracy of 16th steps, so this value would be in 16th steps.
     
     Parameters:
         index<int>: Index of the motor.
         value<longlong>: The current position of the motor.
     
     Exceptions:
         RuntimeError - If current platform is not supported/phidget c dll cannot be found
         PhidgetException: If this Phidget is not opened and attached, or if the index or position are invalid.
     """
     try:
         result = PhidgetLibrary.getDll().CPhidgetStepper_setCurrentPosition(self.handle, c_int(index), c_longlong(value))
     except RuntimeError:
         raise
     
     if result > 0:
         raise PhidgetException(result)

 def setOnVelocityChangeHandler(self, velocityChangeHandler):
     """Sets the VelocityChange event handler.
     
     The velocity change handler is a method that will be called when the stepper velocity has changed.
     
     Parameters:
         velocityChangeHandler: hook to the velocityChangeHandler callback function.
     
     Exceptions:
         RuntimeError - If current platform is not supported/phidget c dll cannot be found
         PhidgetException
     """
     if velocityChangeHandler == None:
         self.__velocityChange = None
         self.__onVelocityChange = None
     else:
         self.__velocityChange = velocityChangeHandler
         self.__onVelocityChange = self.__VELOCITYCHANGEHANDLER(self.__nativeVelocityChangeEvent)
     
     try:
         result = PhidgetLibrary.getDll().CPhidgetStepper_set_OnVelocityChange_Handler(self.handle, self.__onVelocityChange, None)
     except RuntimeError:
         self.__velocityChange = None
         self.__onVelocityChange = None
         raise
     
     if result > 0:
         raise PhidgetException(result)

 def getVelocityMin(self, index):
     """Returns the minimum velocity that a stepper motor will accept, or return.
     
     This value uses the same units as setVelocityLimit/getVelocityLimit and getVelocity.
     
     Parameters:
         index<int>: The index of the motor.
     
     Returns:
         The minimum allowable velocity of the motor <double>.
     
     Exceptions:
         RuntimeError - If current platform is not supported/phidget c dll cannot be found
         PhidgetException: If this Phidget is not opened and attached, or if the index is invalid.
     """
     velocityMin = c_double()
     
     try:
         result = PhidgetLibrary.getDll().CPhidgetStepper_getVelocityMin(self.handle, c_int(index), byref(velocityMin))
     except RuntimeError:
         raise
     
     if result > 0:
         raise PhidgetException(result)
     else:
         return velocityMin.value

 def getVelocity(self, index):
     """Returns a motor's current velocity.
     
     The valid range is between getVelocityMin and getVelocityMax, with 0 being stopped.
     This value is in (micro)steps per second. The step unit will depend on the Stepper Controller.
     For example, the Bipolar Stepper controller has an accuracy of 16th steps, so this value would be in 16th steps per second.
     
     Parameters:
         index<int>: The index of the motor.
     
     Returns:
         The current velocity of the motor <double>.
     
     Exceptions:
         RuntimeError - If current platform is not supported/phidget c dll cannot be found
         PhidgetException: If this Phidget is not opened and attached, or if the index is invalid, or if the velocity in unknown.
     """
     velocity = c_double()
     
     try:
         result = PhidgetLibrary.getDll().CPhidgetStepper_getVelocity(self.handle, c_int(index), byref(velocity))
     except RuntimeError:
         raise
     
     if result > 0:
         raise PhidgetException(result)
     else:
         return velocity.value

 def getInputState(self, index):
     """Returns the state of a digital input.
     
     True means that the input is activated, and False indicated the default state.
     
     Parameters:
         index<int>: The index of the input.
     
     Returns:
         The state of the input <boolean>.
     
     Exceptions:
         RuntimeError - If current platform is not supported/phidget c dll cannot be found
         PhidgetException: If this Phidget is not opened and attached, or if the index is invalid.
     """
     inputState = c_int()
     
     try:
         result = PhidgetLibrary.getDll().CPhidgetStepper_getInputState(self.handle, c_int(index), byref(inputState))
     except RuntimeError:
         raise
     
     if result > 0:
         raise PhidgetException(result)
     else:
         if inputState.value == 1:
             return True
         else:
             return False