htpio.bridge API documentation
Description: This module provides the connection between the client application and the remote i/o implementation …

# Module `htpio.bridge`

This module provides the connection between the client application and the remote i/o implementation.

Example :

    import time
    import htpio.bridge as bridge
    import htpio.telnetio as telnetio
    import htpio.socketio as socketio

    device = telnetio.RaspberryPi('192.168.199.31')
    gpio = bridge.RemoteAccess(device)

    gpio.lock(14)
    gpio.configure(14, gpio.OUTPUT)

    gpio.set(14, 1)
    time.sleep(1)
    gpio.set(14, 0)

    gpio.unlock(14)
    gpio.deconfigure(14)
    gpio.logout()

    device = socketio.RaspberryPi('192.168.199.31')
    gpio = bridge.RemoteAccess(device)

    gpio.lock(15)
    gpio.configure(15, gpio.OUTPUT)

    gpio.set(15, 1)
    time.sleep(1)
    gpio.set(15, 0)

    gpio.unlock(15)
    gpio.deconfigure(15)
    gpio.logout()

Source code

    # Copyright (c) Hilscher GmbH. All Rights Reserved.
    #
    # $Author: bgeorgiev $
    # $Date: 2019-05-16 11:34:02 +0300 (Thu, 16 May 2019) $
    # $Revision: 654 $

    """
    This module provides the connection between the client application and the
    remote i/o implementation.

    *** Example *** :

    ```
    import time
    import htpio.bridge as bridge
    import htpio.telnetio as telnetio
    import htpio.socketio as socketio

    device = telnetio.RaspberryPi('192.168.199.31')
    gpio = bridge.RemoteAccess(device)

    gpio.lock(14)
    gpio.configure(14, gpio.OUTPUT)

    gpio.set(14, 1)
    time.sleep(1)
    gpio.set(14, 0)

    gpio.unlock(14)
    gpio.deconfigure(14)
    gpio.logout()

    device = socketio.RaspberryPi('192.168.199.31')
    gpio = bridge.RemoteAccess(device)

    gpio.lock(15)
    gpio.configure(15, gpio.OUTPUT)

    gpio.set(15, 1)
    time.sleep(1)
    gpio.set(15, 0)

    gpio.unlock(15)
    gpio.deconfigure(15)
    gpio.logout()

    ```

    """

    # Compatibility imports
    from __future__ import unicode_literals
    from __future__ import absolute_import

    # System imports
    from abc import ABCMeta, abstractmethod

    """
    #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    #  Class Device : Implementor interface abstraction
    #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    """

    class Device(object):
        """
        Define the implementor's interface from the bridge pattern. This interface
        provides homogeneous interface for all remote I/O libraries.

        Typically the implementor interface provides only primitive operations,
        and abstraction defines higher-level operations based on these primitives.
        """

        __metaclass__ = ABCMeta

        INPUT = 0
        """ Pin input mode"""

        OUTPUT = 1
        """ Pin output mode"""

        @abstractmethod
        def islocked(self, pin):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def lock(self, pin):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def unlock(self, pin):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def isconfigured(self, pin):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def configure(self, pin, direction):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def deconfigure(self, pin):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def login(self):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def logout(self):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def get(self, pin):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def set(self, pin, value):
            """ Abstract method """
            raise NotImplementedError

        @abstractmethod
        def reset(self, pin):
            """ Abstract method """
            raise NotImplementedError

    """
    #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    #  Class RemoteAccess : Bridge interface for client applications
    #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    """

    class RemoteAccess(object):

        """
        Define the abstraction's interface from the bridge pattern used by the
        client application.

        Typically the implementor interface provides only primitive operations,
        and abstraction defines higher-level operations based on these primitives.
        """

        def __init__(self, device_api):

            # Define instance attributes. These cannot be defined as class
            # attributes as bridge might have different types of in/out
            # and max_gpio definitions.

            self.INPUT = device_api.INPUT
            self.OUTPUT = device_api.OUTPUT
            self.MAX_GPIO = device_api.MAX_GPIO

            # Define interface for remote access
            self._device_api = device_api

        def islocked(self, pin):
            """
            Check if pin is locked by another process

            *** Example: ***
            ```python
            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.lock(14)
            if led.islocked(14):
                print("LED is locked!!!")
            led.logout()
            ...
            ```
            """

            return self._device_api.islocked(pin)

        def lock(self, pin):
            """
            Lock pin if it is not used

            *** Example: ***
            ```python
            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.lock(14)
            ...
            ```

            """

            return self._device_api.lock(pin)

        def unlock(self, pin):
            """
            Unlock pin if it belongs to my session

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.unlock(14)
            ...
            ```
            """

            return self._device_api.unlock(pin)

        def isconfigured(self, pin):
            """
            Check if pin is configured

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.isconfigured(14)
            ...
            ```

            """

            return self._device_api.isconfigured(pin)

        def configure(self, pin, direction):
            """
            Configure pin with direction if it is free

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.configure(14, led.OUTPUT)
            led.set(14, 1)
            ...
            ```
            """

            return self._device_api.configure(pin, direction)

        def deconfigure(self, pin):
            """
            Deconfigure pin if it belongs to my session

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.deconfigure(14)
            ...
            ```

            """

            return self._device_api.deconfigure(pin)

        def login(self):
            """
            Registers to remote device

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.login()
            ...
            ```

            """

            return self._device_api.login()

        def logout(self):
            """
            Unregisters from remote device

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.logout()
            ...
            ```
            """

            return self._device_api.logout()

        def get(self, pin):
            """
            Get pin value

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.configure(14, led.OUTPUT)
            led.set(14, 1)
            print(led.get(14))
            ...
            ```

            """

            return self._device_api.get(pin)

        def set(self, pin, value):
            """
            Write value to pin

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.configure(14, led.OUTPUT)
            led.set(14, 1)
            print(led.get(14))
            ...
            ```

            """

            return self._device_api.set(pin, value)

        def reset(self, pin):
            """
            Remove pin lock forcefully

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.lock(14)
            print(led.islocked(14))
            led.reset(14)
            print(led.islocked(14))
            ...
            ```

            """

            return self._device_api.reset(pin)

## Classes

`class Device (*args, **kwargs)`

  Define the implementor's interface from the bridge pattern. This interface provides homogeneous interface for all remote I/O libraries.

  Typically the implementor interface provides only primitive operations, and abstraction defines higher-level operations based on these primitives.

  Source code

      class Device(object):
          """
          Define the implementor's interface from the bridge pattern. This interface
          provides homogeneous interface for all remote I/O libraries.

          Typically the implementor interface provides only primitive operations,
          and abstraction defines higher-level operations based on these primitives.
          """

          __metaclass__ = ABCMeta

          INPUT = 0
          """ Pin input mode"""

          OUTPUT = 1
          """ Pin output mode"""

          @abstractmethod
          def islocked(self, pin):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def lock(self, pin):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def unlock(self, pin):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def isconfigured(self, pin):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def configure(self, pin, direction):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def deconfigure(self, pin):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def login(self):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def logout(self):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def get(self, pin):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def set(self, pin, value):
              """ Abstract method """
              raise NotImplementedError

          @abstractmethod
          def reset(self, pin):
              """ Abstract method """
              raise NotImplementedError

  ### Subclasses

  - RaspberryPi
  - RaspberryPi

  ### Class variables

  `var INPUT`

    Pin input mode

  `var OUTPUT`

    Pin output mode

  ### Methods

  `def configure(self, pin, direction)`

    Abstract method

    Source code

        @abstractmethod
        def configure(self, pin, direction):
            """ Abstract method """
            raise NotImplementedError

  `def deconfigure(self, pin)`

    Abstract method

    Source code

        @abstractmethod
        def deconfigure(self, pin):
            """ Abstract method """
            raise NotImplementedError

  `def get(self, pin)`

    Abstract method

    Source code

        @abstractmethod
        def get(self, pin):
            """ Abstract method """
            raise NotImplementedError

  `def isconfigured(self, pin)`

    Abstract method

    Source code

        @abstractmethod
        def isconfigured(self, pin):
            """ Abstract method """
            raise NotImplementedError

  `def islocked(self, pin)`

    Abstract method

    Source code

        @abstractmethod
        def islocked(self, pin):
            """ Abstract method """
            raise NotImplementedError

  `def lock(self, pin)`

    Abstract method

    Source code

        @abstractmethod
        def lock(self, pin):
            """ Abstract method """
            raise NotImplementedError

  `def login(self)`

    Abstract method

    Source code

        @abstractmethod
        def login(self):
            """ Abstract method """
            raise NotImplementedError

  `def logout(self)`

    Abstract method

    Source code

        @abstractmethod
        def logout(self):
            """ Abstract method """
            raise NotImplementedError

  `def reset(self, pin)`

    Abstract method

    Source code

        @abstractmethod
        def reset(self, pin):
            """ Abstract method """
            raise NotImplementedError

  `def set(self, pin, value)`

    Abstract method

    Source code

        @abstractmethod
        def set(self, pin, value):
            """ Abstract method """
            raise NotImplementedError

  `def unlock(self, pin)`

    Abstract method

    Source code

        @abstractmethod
        def unlock(self, pin):
            """ Abstract method """
            raise NotImplementedError

`class RemoteAccess (device_api)`

  Define the abstraction's interface from the bridge pattern used by the client application.

  Typically the implementor interface provides only primitive operations, and abstraction defines higher-level operations based on these primitives.

  Source code

      class RemoteAccess(object):

          """
          Define the abstraction's interface from the bridge pattern used by the
          client application.

          Typically the implementor interface provides only primitive operations,
          and abstraction defines higher-level operations based on these primitives.
          """

          def __init__(self, device_api):

              # Define instance attributes. These cannot be defined as class
              # attributes as bridge might have different types of in/out
              # and max_gpio definitions.

              self.INPUT = device_api.INPUT
              self.OUTPUT = device_api.OUTPUT
              self.MAX_GPIO = device_api.MAX_GPIO

              # Define interface for remote access
              self._device_api = device_api

          def islocked(self, pin):
              """
              Check if pin is locked by another process

              *** Example: ***
              ```python
              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.lock(14)
              if led.islocked(14):
                  print("LED is locked!!!")
              led.logout()
              ...
              ```
              """

              return self._device_api.islocked(pin)

          def lock(self, pin):
              """
              Lock pin if it is not used

              *** Example: ***
              ```python
              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.lock(14)
              ...
              ```

              """

              return self._device_api.lock(pin)

          def unlock(self, pin):
              """
              Unlock pin if it belongs to my session

              ***Example***:
              ```python

              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.unlock(14)
              ...
              ```
              """

              return self._device_api.unlock(pin)

          def isconfigured(self, pin):
              """
              Check if pin is configured

              ***Example***:
              ```python

              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.isconfigured(14)
              ...
              ```

              """

              return self._device_api.isconfigured(pin)

          def configure(self, pin, direction):
              """
              Configure pin with direction if it is free

              ***Example***:
              ```python

              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.configure(14, led.OUTPUT)
              led.set(14, 1)
              ...
              ```
              """

              return self._device_api.configure(pin, direction)

          def deconfigure(self, pin):
              """
              Deconfigure pin if it belongs to my session

              ***Example***:
              ```python

              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.deconfigure(14)
              ...
              ```

              """

              return self._device_api.deconfigure(pin)

          def login(self):
              """
              Registers to remote device

              ***Example***:
              ```python

              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.login()
              ...
              ```

              """

              return self._device_api.login()

          def logout(self):
              """
              Unregisters from remote device

              ***Example***:
              ```python

              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.logout()
              ...
              ```
              """

              return self._device_api.logout()

          def get(self, pin):
              """
              Get pin value

              ***Example***:
              ```python

              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.configure(14, led.OUTPUT)
              led.set(14, 1)
              print(led.get(14))
              ...
              ```

              """

              return self._device_api.get(pin)

          def set(self, pin, value):
              """
              Write value to pin

              ***Example***:
              ```python

              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.configure(14, led.OUTPUT)
              led.set(14, 1)
              print(led.get(14))
              ...
              ```

              """

              return self._device_api.set(pin, value)

          def reset(self, pin):
              """
              Remove pin lock forcefully

              ***Example***:
              ```python

              from htpio.bridge import RemoteAccess
              from htpio import telnetio, socketio

              remoteio = socketio.RaspberryPi('192.168.199.31')
              led = RemoteAccess(remoteio)
              led.lock(14)
              print(led.islocked(14))
              led.reset(14)
              print(led.islocked(14))
              ...
              ```

              """

              return self._device_api.reset(pin)

  ### Methods

  `def configure(self, pin, direction)`

    Configure pin with direction if it is free

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.configure(14, led.OUTPUT)
        led.set(14, 1)
        ...

    Source code

        def configure(self, pin, direction):
            """
            Configure pin with direction if it is free

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.configure(14, led.OUTPUT)
            led.set(14, 1)
            ...
            ```
            """

            return self._device_api.configure(pin, direction)

  `def deconfigure(self, pin)`

    Deconfigure pin if it belongs to my session

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.deconfigure(14)
        ...

    Source code

        def deconfigure(self, pin):
            """
            Deconfigure pin if it belongs to my session

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.deconfigure(14)
            ...
            ```

            """

            return self._device_api.deconfigure(pin)

  `def get(self, pin)`

    Get pin value

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.configure(14, led.OUTPUT)
        led.set(14, 1)
        print(led.get(14))
        ...

    Source code

        def get(self, pin):
            """
            Get pin value

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.configure(14, led.OUTPUT)
            led.set(14, 1)
            print(led.get(14))
            ...
            ```

            """

            return self._device_api.get(pin)

  `def isconfigured(self, pin)`

    Check if pin is configured

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.isconfigured(14)
        ...

    Source code

        def isconfigured(self, pin):
            """
            Check if pin is configured

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.isconfigured(14)
            ...
            ```

            """

            return self._device_api.isconfigured(pin)

  `def islocked(self, pin)`

    Check if pin is locked by another process

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.lock(14)
        if led.islocked(14):
            print("LED is locked!!!")
        led.logout()
        ...

    Source code

        def islocked(self, pin):
            """
            Check if pin is locked by another process

            *** Example: ***
            ```python
            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.lock(14)
            if led.islocked(14):
                print("LED is locked!!!")
            led.logout()
            ...
            ```
            """

            return self._device_api.islocked(pin)

  `def lock(self, pin)`

    Lock pin if it is not used

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.lock(14)
        ...

    Source code

        def lock(self, pin):
            """
            Lock pin if it is not used

            *** Example: ***
            ```python
            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.lock(14)
            ...
            ```

            """

            return self._device_api.lock(pin)

  `def login(self)`

    Registers to remote device

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.login()
        ...

    Source code

        def login(self):
            """
            Registers to remote device

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.login()
            ...
            ```

            """

            return self._device_api.login()

  `def logout(self)`

    Unregisters from remote device

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.logout()
        ...

    Source code

        def logout(self):
            """
            Unregisters from remote device

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.logout()
            ...
            ```
            """

            return self._device_api.logout()

  `def reset(self, pin)`

    Remove pin lock forcefully

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.lock(14)
        print(led.islocked(14))
        led.reset(14)
        print(led.islocked(14))
        ...

    Source code

        def reset(self, pin):
            """
            Remove pin lock forcefully

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.lock(14)
            print(led.islocked(14))
            led.reset(14)
            print(led.islocked(14))
            ...
            ```

            """

            return self._device_api.reset(pin)

  `def set(self, pin, value)`

    Write value to pin

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.configure(14, led.OUTPUT)
        led.set(14, 1)
        print(led.get(14))
        ...

    Source code

        def set(self, pin, value):
            """
            Write value to pin

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.configure(14, led.OUTPUT)
            led.set(14, 1)
            print(led.get(14))
            ...
            ```

            """

            return self._device_api.set(pin, value)

  `def unlock(self, pin)`

    Unlock pin if it belongs to my session

    Example:

        from htpio.bridge import RemoteAccess
        from htpio import telnetio, socketio

        remoteio = socketio.RaspberryPi('192.168.199.31')
        led = RemoteAccess(remoteio)
        led.unlock(14)
        ...

    Source code

        def unlock(self, pin):
            """
            Unlock pin if it belongs to my session

            ***Example***:
            ```python

            from htpio.bridge import RemoteAccess
            from htpio import telnetio, socketio

            remoteio = socketio.RaspberryPi('192.168.199.31')
            led = RemoteAccess(remoteio)
            led.unlock(14)
            ...
            ```
            """

            return self._device_api.unlock(pin)