htpio.socketio API documentation
Description: This is a socket i/o control module wrapping the python pigpio client. PIGPIO is a client/server library using sockets for remote control of the …

# Module `htpio.socketio`

This is a socket i/o control module wrapping the python pigpio client. PIGPIO is a client/server library using sockets for remote control of the general purpose input outputs(GPIO).

Example:

    import htpio.socketio as socketio

    r = socketio.RaspberryPi(host = '192.168.199.31',
                             port = 8888)

    try:
        r.lock(14)
    except:
        r.logout()
        raise

    r.configure(14, socketio.RaspberryPi.OUTPUT)
    r.set(14, 1)

    print(r.get(14))

    r.unlock(14)
    r.deconfigure(14)

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 is a socket i/o control module wrapping the python pigpio client.
    PIGPIO is a client/server library using sockets for remote control of
    the general purpose input outputs(GPIO).

    *** Example: ***

    ```python

    import htpio.socketio as socketio

    r = socketio.RaspberryPi(host = '192.168.199.31',
                             port = 8888)

    try:
        r.lock(14)
    except:
        r.logout()
        raise

    r.configure(14, socketio.RaspberryPi.OUTPUT)
    r.set(14, 1)

    print(r.get(14))

    r.unlock(14)
    r.deconfigure(14)
    ```

    """

    # Compatibility imports
    from __future__ import unicode_literals
    from __future__ import absolute_import

    # Third party imports
    import pigpio

    # Local imports
    from htpio.exceptions import PinLockedByOtherProcess, CannotConnectToTarget
    from htpio.bridge import Device

    """
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    # DEVICE CLASSES : RaspberryPi, OrangePi, Arduino, etc.
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    """

    class RaspberryPi(pigpio.pi, Device):

        """
        This class allows users to connect and control the GPIO
        on a Raspberry remotely by using and extending the pigpio library.

        ## Configuration

        Enable Remote GPIO

            sudo raspi-config
            Menu : Interfacing Options -> Remote GPIO

        Enable pigpiod to start on boot

            sudo systemctl enable pigpiod

        ## Class attributes

            LOCK_DIR        : Location of lock files (ramdisk)
            MAX_GPIO        : Maximum number of gpio locks ( from 0 .. MAX)
            INPUT           : GPIO is digital input
            OUTPUT          : GPIO is digital output
            EOF             : End of file

        ## Instance attributes

            host            : ip v4 address
            port            : port (from 0 to 65535)

        ## Public methods

            islocked(gpio)              : Check if the gpio is locked
            lock(gpio)                  : Locks the gpio
            unlock(gpio)                : Unlocks the gpio
            isconfigured(gpio)          : Checks if the gpio is configured
            configure(gpio, direction)  : Configures the gpio with direction
            deconfigure(gpio)           : Restores the default configuration
            get(gpio)                   : Reads the gpio status
            set(gpio, value)            : Writes new value to gpio
            login()                     : Registers to the remote system
            logout()                    : Unregisters from the remote system
            reset()                     : Deletes all configuration data

        """

        MAX_GPIO = 128
        """ Maximum number of GPIOs """

        INPUT = pigpio.INPUT
        """ Signal direction is INPUT """

        OUTPUT = pigpio.OUTPUT
        """ Signal direction is OUTPUT """

        LOCKDIR = "/tmp/htp/locks"
        """ Lock files directory """

        EOF = "\n"
        """ Symbol for end of transmission """

        def __init__(self, host=None, port=8888):
            """
            ## Constructor

            When called with host address, the constructor creates
            a telnet connection and performs automatic login (default=8888).

            ```python
            import htpio.socketio as socketio

            t = socketio.RaspberryPi('192.168.199.31')
            ```

            """

            pigpio.pi.__init__(self, host, port)

            self._host = host
            self._port = port
            self._session = None
            self._iotag = "gpio"
            self._lockdir = RaspberryPi.LOCKDIR

            if host is not None:
                self.login()

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  islocked : Check if pin is locked and returns the owner
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def islocked(self, pin):
            """
            Opens the gpio lock file and checks it size. If the size is more than
            zero then the gpio is considered to be locked by another process.

            *** Example: ***
            ```python
            import htpio.socketio as socketio

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

            # Consistent directory name
            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            # Generate lock file name
            iotag = self._iotag + str(pin)
            lockfile = (self._lockdir + iotag)

            # Prepare mode
            mode = pigpio.FILE_READ
            h = self.file_open(lockfile.encode('ascii'), mode)

            # Read file
            (size, data) = self.file_read(h, 100)

            # Evaluate result
            if size > 0:

                # Someone is locking the file
                result = data.decode()
                result = result.replace(self.EOF, "")

            else:

                # Nobody is locking the file
                result = None

            self.file_close(h)

            return result

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  lock : Open the lock file and write this instance socket parameters
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def lock(self, pin):
            """
            Lock the given pin by creating a lock file and writing the current
            session id into it.

            ***Example***:
            ```python
            import htpio.socketio as socketio

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

            # Consistent directory name
            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            # Generate lock file name
            iotag = self._iotag + str(pin)
            lockfile = self._lockdir + iotag

            # Check ownership and lock
            lock_owner = self.islocked(pin)

            if lock_owner is not None:
                raise PinLockedByOtherProcess(lock_owner.encode('ascii'),
                                              self._session)
            else:

                # Prepare mode
                mode = pigpio.FILE_WRITE | pigpio.FILE_CREATE
                h = self.file_open(lockfile.encode('ascii'), mode)

                # Write content
                content = (self._session + RaspberryPi.EOF).encode('ascii')
                self.file_write(h, content)

                # Close file
                self.file_close(h)

            return 0

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  unlock : Opens the corresponding file and erases the content
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def unlock(self, pin):
            """
            Unlock the pin by truncating the size of the lock file to zero.

            ***Example***:
            ```python
            import htpio.socketio as socketio

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

            """

            # Verify is pin is locked by other process
            lock_owner = self.islocked(pin)
            if lock_owner is not None and lock_owner != self._session:
                raise PinLockedByOtherProcess(lock_owner, self._session)

            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            iotag = self._iotag + str(pin)
            lockfile = self._lockdir + iotag

            h = self.file_open(lockfile.encode('ascii'),
                               pigpio.FILE_READ |
                               pigpio.FILE_TRUNC)

            self.file_close(h)

            return 0

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        # isconfigured : Check if the pin is configured (mode <> default)
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def isconfigured(self, pin):
            """
            Check if gpio is configured by comparing the current direction
            configuration with the default one (INPUT).

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.configure(14, socketio.RaspberryPi.OUTPUT)
            if led.isconfigured(14):
                print("LED is configured!!!")
            ...
            ```
            """

            return self.get_mode(pin)

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  configure : Configures pin mode using pigpio
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def configure(self, pin, direction):
            """
            Configures the gpio for input or output operation.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.configure(14, socketio.RaspberryPi.OUTPUT)
            ...
            ```
            """

            # Verify is pin is locked by other process
            lock_owner = self.islocked(pin)
            if lock_owner is not None and lock_owner != self._session:
                raise PinLockedByOtherProcess(lock_owner, self._session)

            self.set_mode(pin, direction)

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  cleanup : Resets pin configuration to the default value (INPUT)
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def deconfigure(self, pin):
            """
            Removes the gpio configuration.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.deconfigure(14)
            ...
            ```
            """

            # Verify is pin is locked by other process
            lock_owner = self.islocked(pin)
            if lock_owner is not None and lock_owner != self._session:
                raise PinLockedByOtherProcess(lock_owner, self._session)

            self.set(pin, 0)
            self.set_mode(pin, pigpio.INPUT)

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  get : Reads the value of the pin using pigpio
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def get(self, pin):
            """
            Reads the value of the gpio.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.get(14)
            ...
            ```
            """

            return self.read(pin)

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  set : Writes to the pin using pigpio
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def set(self, pin, value):
            """
            Writes the value to the gpio.

            *** Example: ***
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.configure(14, socketio.RaspberryPi.OUTPUT)
            led.set(14, 1)
            ...
            ```
            """

            # Verify is pin is locked by other process
            lock_owner = self.islocked(pin)
            if lock_owner is not None and lock_owner != self._session:
                raise PinLockedByOtherProcess(lock_owner, self._session)

            self.write(pin, value)

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  login : Check for connectivity and create lock files
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def login(self):
            """
            Registers device for use with target device by checking for
            an established connection and creating all gpio lock files.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi()
            led.host = '192.168.199.31'
            led.port = 8888
            led.login()
            ...
            ```
            """

            # Check if socket connection is up
            if not self.connected:
                raise CannotConnectToTarget

            # Check if device is already registered
            if not self._session:
                self._session = self.__session()
                self.__populate()

            return 0

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  logout : Close socket
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

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

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.logout()

            ...
            ```
            """

            self.stop()

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  reset : Deletes all coockies
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def reset(self, pin):
            """
            Deletes the content of all generated lock files.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.reset(14)

            ...
            ```
            """

            # Consistent directory name
            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            # Generate lock file name
            iotag = self._iotag + str(pin)
            lockfile = self._lockdir + iotag

            h = self.file_open(file_name=lockfile.encode('ascii'),
                               file_mode=pigpio.FILE_READ | pigpio.FILE_TRUNC)

            self.file_close(h)

            return 0

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  session : Retrieves connection data and generates a lock identification
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def __session(self):
            """
            Gets the socket data for this connection and converts the to one
            unique identification number. This ID is used to lock gpios.
            """

            mysocket = self.sl.s
            mysocket = mysocket.getsockname()
            result = '.'.join(map(str, mysocket))
            result = result.replace(".", "")

            return result

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  locklist : retries all gpios currently locked by other processes
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def __locklist(self):
            """
            Gets a listing of all lock files in the lock directory.
            """

            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            lockdir = self._lockdir + "*"

            # Function returns number of bytes(r) and a byte array(r2)
            size, data = self.file_list(lockdir.encode('ascii'))

            result = []
            if size > 0:
                data = data.decode()
                data = data.split(RaspberryPi.EOF)

                for element in data[:-1]:
                    result.append(element)

            return result

        """
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        #  populate : generate GPIO lock files from 0 to MAX_GPIO
        #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        """

        def __populate(self):
            """ Creates all lock files in the lock directory. """

            # Consistent directory name
            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            # Generate lock files
            for gpio in range(RaspberryPi.MAX_GPIO):
                iotag = self._iotag + str(gpio)
                lockfile = self._lockdir + iotag

                h = self.file_open(file_name=lockfile.encode('ascii'),
                                   file_mode=pigpio.FILE_WRITE | pigpio.FILE_CREATE)

                self.file_close(h)

            return 0

## Classes

`class RaspberryPi (host=None, port=8888)`

  This class allows users to connect and control the GPIO on a Raspberry remotely by using and extending the pigpio library.

  ## Configuration

  Enable Remote GPIO

      sudo raspi-config
      Menu : Interfacing Options -> Remote GPIO

  Enable pigpiod to start on boot

      sudo systemctl enable pigpiod

  ## Class attributes

      LOCK_DIR        : Location of lock files (ramdisk)
      MAX_GPIO        : Maximum number of gpio locks ( from 0 .. MAX)
      INPUT           : GPIO is digital input
      OUTPUT          : GPIO is digital output
      EOF             : End of file

  ## Instance attributes

      host            : ip v4 address
      port            : port (from 0 to 65535)

  ## Public methods

      islocked(gpio)              : Check if the gpio is locked
      lock(gpio)                  : Locks the gpio
      unlock(gpio)                : Unlocks the gpio
      isconfigured(gpio)          : Checks if the gpio is configured
      configure(gpio, direction)  : Configures the gpio with direction
      deconfigure(gpio)           : Restores the default configuration
      get(gpio)                   : Reads the gpio status
      set(gpio, value)            : Writes new value to gpio
      login()                     : Registers to the remote system
      logout()                    : Unregisters from the remote system
      reset()                     : Deletes all configuration data

  ## Constructor

  When called with host address, the constructor creates a telnet connection and performs automatic login (default=8888).

      import htpio.socketio as socketio

      t = socketio.RaspberryPi('192.168.199.31')

  Source code

      class RaspberryPi(pigpio.pi, Device):

          """
          This class allows users to connect and control the GPIO
          on a Raspberry remotely by using and extending the pigpio library.

          ## Configuration

          Enable Remote GPIO

              sudo raspi-config
              Menu : Interfacing Options -> Remote GPIO

          Enable pigpiod to start on boot

              sudo systemctl enable pigpiod

          ## Class attributes

              LOCK_DIR        : Location of lock files (ramdisk)
              MAX_GPIO        : Maximum number of gpio locks ( from 0 .. MAX)
              INPUT           : GPIO is digital input
              OUTPUT          : GPIO is digital output
              EOF             : End of file

          ## Instance attributes

              host            : ip v4 address
              port            : port (from 0 to 65535)

          ## Public methods

              islocked(gpio)              : Check if the gpio is locked
              lock(gpio)                  : Locks the gpio
              unlock(gpio)                : Unlocks the gpio
              isconfigured(gpio)          : Checks if the gpio is configured
              configure(gpio, direction)  : Configures the gpio with direction
              deconfigure(gpio)           : Restores the default configuration
              get(gpio)                   : Reads the gpio status
              set(gpio, value)            : Writes new value to gpio
              login()                     : Registers to the remote system
              logout()                    : Unregisters from the remote system
              reset()                     : Deletes all configuration data

          """

          MAX_GPIO = 128
          """ Maximum number of GPIOs """

          INPUT = pigpio.INPUT
          """ Signal direction is INPUT """

          OUTPUT = pigpio.OUTPUT
          """ Signal direction is OUTPUT """

          LOCKDIR = "/tmp/htp/locks"
          """ Lock files directory """

          EOF = "\n"
          """ Symbol for end of transmission """

          def __init__(self, host=None, port=8888):
              """
              ## Constructor

              When called with host address, the constructor creates
              a telnet connection and performs automatic login (default=8888).

              ```python
              import htpio.socketio as socketio

              t = socketio.RaspberryPi('192.168.199.31')
              ```

              """

              pigpio.pi.__init__(self, host, port)

              self._host = host
              self._port = port
              self._session = None
              self._iotag = "gpio"
              self._lockdir = RaspberryPi.LOCKDIR

              if host is not None:
                  self.login()

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  islocked : Check if pin is locked and returns the owner
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def islocked(self, pin):
              """
              Opens the gpio lock file and checks it size. If the size is more than
              zero then the gpio is considered to be locked by another process.

              *** Example: ***
              ```python
              import htpio.socketio as socketio

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

              # Consistent directory name
              if not self._lockdir.endswith("/"):
                  self._lockdir = self._lockdir + "/"

              # Generate lock file name
              iotag = self._iotag + str(pin)
              lockfile = (self._lockdir + iotag)

              # Prepare mode
              mode = pigpio.FILE_READ
              h = self.file_open(lockfile.encode('ascii'), mode)

              # Read file
              (size, data) = self.file_read(h, 100)

              # Evaluate result
              if size > 0:

                  # Someone is locking the file
                  result = data.decode()
                  result = result.replace(self.EOF, "")

              else:

                  # Nobody is locking the file
                  result = None

              self.file_close(h)

              return result

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  lock : Open the lock file and write this instance socket parameters
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def lock(self, pin):
              """
              Lock the given pin by creating a lock file and writing the current
              session id into it.

              ***Example***:
              ```python
              import htpio.socketio as socketio

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

              # Consistent directory name
              if not self._lockdir.endswith("/"):
                  self._lockdir = self._lockdir + "/"

              # Generate lock file name
              iotag = self._iotag + str(pin)
              lockfile = self._lockdir + iotag

              # Check ownership and lock
              lock_owner = self.islocked(pin)

              if lock_owner is not None:
                  raise PinLockedByOtherProcess(lock_owner.encode('ascii'),
                                                self._session)
              else:

                  # Prepare mode
                  mode = pigpio.FILE_WRITE | pigpio.FILE_CREATE
                  h = self.file_open(lockfile.encode('ascii'), mode)

                  # Write content
                  content = (self._session + RaspberryPi.EOF).encode('ascii')
                  self.file_write(h, content)

                  # Close file
                  self.file_close(h)

              return 0

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  unlock : Opens the corresponding file and erases the content
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def unlock(self, pin):
              """
              Unlock the pin by truncating the size of the lock file to zero.

              ***Example***:
              ```python
              import htpio.socketio as socketio

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

              """

              # Verify is pin is locked by other process
              lock_owner = self.islocked(pin)
              if lock_owner is not None and lock_owner != self._session:
                  raise PinLockedByOtherProcess(lock_owner, self._session)

              if not self._lockdir.endswith("/"):
                  self._lockdir = self._lockdir + "/"

              iotag = self._iotag + str(pin)
              lockfile = self._lockdir + iotag

              h = self.file_open(lockfile.encode('ascii'),
                                 pigpio.FILE_READ |
                                 pigpio.FILE_TRUNC)

              self.file_close(h)

              return 0

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          # isconfigured : Check if the pin is configured (mode <> default)
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def isconfigured(self, pin):
              """
              Check if gpio is configured by comparing the current direction
              configuration with the default one (INPUT).

              ***Example***:
              ```python
              import htpio.socketio as socketio

              led = socketio.RaspberryPi('192.168.199.31')

              led.configure(14, socketio.RaspberryPi.OUTPUT)
              if led.isconfigured(14):
                  print("LED is configured!!!")
              ...
              ```
              """

              return self.get_mode(pin)

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  configure : Configures pin mode using pigpio
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def configure(self, pin, direction):
              """
              Configures the gpio for input or output operation.

              ***Example***:
              ```python
              import htpio.socketio as socketio

              led = socketio.RaspberryPi('192.168.199.31')

              led.configure(14, socketio.RaspberryPi.OUTPUT)
              ...
              ```
              """

              # Verify is pin is locked by other process
              lock_owner = self.islocked(pin)
              if lock_owner is not None and lock_owner != self._session:
                  raise PinLockedByOtherProcess(lock_owner, self._session)

              self.set_mode(pin, direction)

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  cleanup : Resets pin configuration to the default value (INPUT)
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def deconfigure(self, pin):
              """
              Removes the gpio configuration.

              ***Example***:
              ```python
              import htpio.socketio as socketio

              led = socketio.RaspberryPi('192.168.199.31')

              led.deconfigure(14)
              ...
              ```
              """

              # Verify is pin is locked by other process
              lock_owner = self.islocked(pin)
              if lock_owner is not None and lock_owner != self._session:
                  raise PinLockedByOtherProcess(lock_owner, self._session)

              self.set(pin, 0)
              self.set_mode(pin, pigpio.INPUT)

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  get : Reads the value of the pin using pigpio
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def get(self, pin):
              """
              Reads the value of the gpio.

              ***Example***:
              ```python
              import htpio.socketio as socketio

              led = socketio.RaspberryPi('192.168.199.31')

              led.get(14)
              ...
              ```
              """

              return self.read(pin)

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  set : Writes to the pin using pigpio
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def set(self, pin, value):
              """
              Writes the value to the gpio.

              *** Example: ***
              ```python
              import htpio.socketio as socketio

              led = socketio.RaspberryPi('192.168.199.31')

              led.configure(14, socketio.RaspberryPi.OUTPUT)
              led.set(14, 1)
              ...
              ```
              """

              # Verify is pin is locked by other process
              lock_owner = self.islocked(pin)
              if lock_owner is not None and lock_owner != self._session:
                  raise PinLockedByOtherProcess(lock_owner, self._session)

              self.write(pin, value)

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  login : Check for connectivity and create lock files
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def login(self):
              """
              Registers device for use with target device by checking for
              an established connection and creating all gpio lock files.

              ***Example***:
              ```python
              import htpio.socketio as socketio

              led = socketio.RaspberryPi()
              led.host = '192.168.199.31'
              led.port = 8888
              led.login()
              ...
              ```
              """

              # Check if socket connection is up
              if not self.connected:
                  raise CannotConnectToTarget

              # Check if device is already registered
              if not self._session:
                  self._session = self.__session()
                  self.__populate()

              return 0

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  logout : Close socket
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

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

              ***Example***:
              ```python
              import htpio.socketio as socketio

              led = socketio.RaspberryPi('192.168.199.31')

              led.logout()

              ...
              ```
              """

              self.stop()

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  reset : Deletes all coockies
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def reset(self, pin):
              """
              Deletes the content of all generated lock files.

              ***Example***:
              ```python
              import htpio.socketio as socketio

              led = socketio.RaspberryPi('192.168.199.31')

              led.reset(14)

              ...
              ```
              """

              # Consistent directory name
              if not self._lockdir.endswith("/"):
                  self._lockdir = self._lockdir + "/"

              # Generate lock file name
              iotag = self._iotag + str(pin)
              lockfile = self._lockdir + iotag

              h = self.file_open(file_name=lockfile.encode('ascii'),
                                 file_mode=pigpio.FILE_READ | pigpio.FILE_TRUNC)

              self.file_close(h)

              return 0

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  session : Retrieves connection data and generates a lock identification
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def __session(self):
              """
              Gets the socket data for this connection and converts the to one
              unique identification number. This ID is used to lock gpios.
              """

              mysocket = self.sl.s
              mysocket = mysocket.getsockname()
              result = '.'.join(map(str, mysocket))
              result = result.replace(".", "")

              return result

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  locklist : retries all gpios currently locked by other processes
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def __locklist(self):
              """
              Gets a listing of all lock files in the lock directory.
              """

              if not self._lockdir.endswith("/"):
                  self._lockdir = self._lockdir + "/"

              lockdir = self._lockdir + "*"

              # Function returns number of bytes(r) and a byte array(r2)
              size, data = self.file_list(lockdir.encode('ascii'))

              result = []
              if size > 0:
                  data = data.decode()
                  data = data.split(RaspberryPi.EOF)

                  for element in data[:-1]:
                      result.append(element)

              return result

          """
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          #  populate : generate GPIO lock files from 0 to MAX_GPIO
          #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          """

          def __populate(self):
              """ Creates all lock files in the lock directory. """

              # Consistent directory name
              if not self._lockdir.endswith("/"):
                  self._lockdir = self._lockdir + "/"

              # Generate lock files
              for gpio in range(RaspberryPi.MAX_GPIO):
                  iotag = self._iotag + str(gpio)
                  lockfile = self._lockdir + iotag

                  h = self.file_open(file_name=lockfile.encode('ascii'),
                                     file_mode=pigpio.FILE_WRITE | pigpio.FILE_CREATE)

                  self.file_close(h)

              return 0

  ### Ancestors

  - pigpio.pi
  - Device

  ### Class variables

  `var EOF`

    Symbol for end of transmission

  `var LOCKDIR`

    Lock files directory

  `var MAX_GPIO`

    Maximum number of GPIOs

  ### Methods

  `def configure(self, pin, direction)`

    Configures the gpio for input or output operation.

    Example:

        import htpio.socketio as socketio

        led = socketio.RaspberryPi('192.168.199.31')

        led.configure(14, socketio.RaspberryPi.OUTPUT)
        ...

    Source code

        def configure(self, pin, direction):
            """
            Configures the gpio for input or output operation.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.configure(14, socketio.RaspberryPi.OUTPUT)
            ...
            ```
            """

            # Verify is pin is locked by other process
            lock_owner = self.islocked(pin)
            if lock_owner is not None and lock_owner != self._session:
                raise PinLockedByOtherProcess(lock_owner, self._session)

            self.set_mode(pin, direction)

  `def deconfigure(self, pin)`

    Removes the gpio configuration.

    Example:

        import htpio.socketio as socketio

        led = socketio.RaspberryPi('192.168.199.31')

        led.deconfigure(14)
        ...

    Source code

        def deconfigure(self, pin):
            """
            Removes the gpio configuration.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.deconfigure(14)
            ...
            ```
            """

            # Verify is pin is locked by other process
            lock_owner = self.islocked(pin)
            if lock_owner is not None and lock_owner != self._session:
                raise PinLockedByOtherProcess(lock_owner, self._session)

            self.set(pin, 0)
            self.set_mode(pin, pigpio.INPUT)

  `def get(self, pin)`

    Reads the value of the gpio.

    Example:

        import htpio.socketio as socketio

        led = socketio.RaspberryPi('192.168.199.31')

        led.get(14)
        ...

    Source code

        def get(self, pin):
            """
            Reads the value of the gpio.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.get(14)
            ...
            ```
            """

            return self.read(pin)

  `def isconfigured(self, pin)`

    Check if gpio is configured by comparing the current direction configuration with the default one (INPUT).

    Example:

        import htpio.socketio as socketio

        led = socketio.RaspberryPi('192.168.199.31')

        led.configure(14, socketio.RaspberryPi.OUTPUT)
        if led.isconfigured(14):
            print("LED is configured!!!")
        ...

    Source code

        def isconfigured(self, pin):
            """
            Check if gpio is configured by comparing the current direction
            configuration with the default one (INPUT).

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.configure(14, socketio.RaspberryPi.OUTPUT)
            if led.isconfigured(14):
                print("LED is configured!!!")
            ...
            ```
            """

            return self.get_mode(pin)

  `def islocked(self, pin)`

    Opens the gpio lock file and checks it size. If the size is more than zero then the gpio is considered to be locked by another process.

    Example:

        import htpio.socketio as socketio

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

    Source code

        def islocked(self, pin):
            """
            Opens the gpio lock file and checks it size. If the size is more than
            zero then the gpio is considered to be locked by another process.

            *** Example: ***
            ```python
            import htpio.socketio as socketio

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

            # Consistent directory name
            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            # Generate lock file name
            iotag = self._iotag + str(pin)
            lockfile = (self._lockdir + iotag)

            # Prepare mode
            mode = pigpio.FILE_READ
            h = self.file_open(lockfile.encode('ascii'), mode)

            # Read file
            (size, data) = self.file_read(h, 100)

            # Evaluate result
            if size > 0:

                # Someone is locking the file
                result = data.decode()
                result = result.replace(self.EOF, "")

            else:

                # Nobody is locking the file
                result = None

            self.file_close(h)

            return result

  `def lock(self, pin)`

    Lock the given pin by creating a lock file and writing the current session id into it.

    Example:

        import htpio.socketio as socketio

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

    Source code

        def lock(self, pin):
            """
            Lock the given pin by creating a lock file and writing the current
            session id into it.

            ***Example***:
            ```python
            import htpio.socketio as socketio

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

            # Consistent directory name
            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            # Generate lock file name
            iotag = self._iotag + str(pin)
            lockfile = self._lockdir + iotag

            # Check ownership and lock
            lock_owner = self.islocked(pin)

            if lock_owner is not None:
                raise PinLockedByOtherProcess(lock_owner.encode('ascii'),
                                              self._session)
            else:

                # Prepare mode
                mode = pigpio.FILE_WRITE | pigpio.FILE_CREATE
                h = self.file_open(lockfile.encode('ascii'), mode)

                # Write content
                content = (self._session + RaspberryPi.EOF).encode('ascii')
                self.file_write(h, content)

                # Close file
                self.file_close(h)

            return 0

  `def login(self)`

    Registers device for use with target device by checking for an established connection and creating all gpio lock files.

    Example:

        import htpio.socketio as socketio

        led = socketio.RaspberryPi()
        led.host = '192.168.199.31'
        led.port = 8888
        led.login()
        ...

    Source code

        def login(self):
            """
            Registers device for use with target device by checking for
            an established connection and creating all gpio lock files.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi()
            led.host = '192.168.199.31'
            led.port = 8888
            led.login()
            ...
            ```
            """

            # Check if socket connection is up
            if not self.connected:
                raise CannotConnectToTarget

            # Check if device is already registered
            if not self._session:
                self._session = self.__session()
                self.__populate()

            return 0

  `def logout(self)`

    Unregisters device from remote device.

    Example:

        import htpio.socketio as socketio

        led = socketio.RaspberryPi('192.168.199.31')

        led.logout()

        ...

    Source code

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

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.logout()

            ...
            ```
            """

            self.stop()

  `def reset(self, pin)`

    Deletes the content of all generated lock files.

    Example:

        import htpio.socketio as socketio

        led = socketio.RaspberryPi('192.168.199.31')

        led.reset(14)

        ...

    Source code

        def reset(self, pin):
            """
            Deletes the content of all generated lock files.

            ***Example***:
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.reset(14)

            ...
            ```
            """

            # Consistent directory name
            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            # Generate lock file name
            iotag = self._iotag + str(pin)
            lockfile = self._lockdir + iotag

            h = self.file_open(file_name=lockfile.encode('ascii'),
                               file_mode=pigpio.FILE_READ | pigpio.FILE_TRUNC)

            self.file_close(h)

            return 0

  `def set(self, pin, value)`

    Writes the value to the gpio.

    Example:

        import htpio.socketio as socketio

        led = socketio.RaspberryPi('192.168.199.31')

        led.configure(14, socketio.RaspberryPi.OUTPUT)
        led.set(14, 1)
        ...

    Source code

        def set(self, pin, value):
            """
            Writes the value to the gpio.

            *** Example: ***
            ```python
            import htpio.socketio as socketio

            led = socketio.RaspberryPi('192.168.199.31')

            led.configure(14, socketio.RaspberryPi.OUTPUT)
            led.set(14, 1)
            ...
            ```
            """

            # Verify is pin is locked by other process
            lock_owner = self.islocked(pin)
            if lock_owner is not None and lock_owner != self._session:
                raise PinLockedByOtherProcess(lock_owner, self._session)

            self.write(pin, value)

  `def unlock(self, pin)`

    Unlock the pin by truncating the size of the lock file to zero.

    Example:

        import htpio.socketio as socketio

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

    Source code

        def unlock(self, pin):
            """
            Unlock the pin by truncating the size of the lock file to zero.

            ***Example***:
            ```python
            import htpio.socketio as socketio

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

            """

            # Verify is pin is locked by other process
            lock_owner = self.islocked(pin)
            if lock_owner is not None and lock_owner != self._session:
                raise PinLockedByOtherProcess(lock_owner, self._session)

            if not self._lockdir.endswith("/"):
                self._lockdir = self._lockdir + "/"

            iotag = self._iotag + str(pin)
            lockfile = self._lockdir + iotag

            h = self.file_open(lockfile.encode('ascii'),
                               pigpio.FILE_READ |
                               pigpio.FILE_TRUNC)

            self.file_close(h)

            return 0

  ### Inherited members

  - `Device`:
    - `INPUT`
    - `OUTPUT`