docs: def _get_parameter(self, name, tp, timeout=1.0, max_retries=2):
          """ Gets the specified drive parameter.
  
          Gets a parameter from the drive. Only supports ``bool``,
          ``int``, and ``float`` parameters.
  
          Parameters
          ----------
          name : str
              Name of the parameter to check. It is always the command to
              set it but without the value.
          tp : type {bool, int, float}
              The type of the parameter.
          timeout : number, optional
              Optional timeout in seconds to use when reading the
              response. A negative value or ``None`` indicates that the
              an infinite timeout should be used.
          max_retries : int, optional
              Maximum number of retries to do per command in the case of
              errors.
  
          Returns
          -------
          value : bool, int, or float
              The value of the specified parameter.
  
          Raises
          ------
          TypeError
              If 'tp' is not an allowed type (``bool``, ``int``,
              ``float``).
          CommandError
              If the command to retrieve the parameter returned an error.
          ValueError
              If the value returned to the drive cannot be converted to
              the proper type.
  
          See Also
          --------
          _set_parameter : Set a parameter.
  
          """
          # Raise a TypeError if tp isn't one of the valid types.
          if tp not in (bool, int, float):
              raise TypeError('Only supports bool, int, and float; not '
                        + str(tp))
  
          # Sending a command of name queries the state for that
          # parameter. The response will have name preceeded by an '*' and
          # then followed by a number which will have to be converted.
          response = self.driver.send_command(name, timeout=timeout,
                                              immediate=True,
                                              max_retries=max_retries)
  
          # If the response has an error, there are no response lines, or
          # the first response line isn't '*'+name; then there was an
          # error and an exception needs to be thrown.
          if self.driver.command_error(response) \
                  or len(response[4]) == 0 \
                  or not response[4][0].startswith('*' + name):
              raise CommandError('Couldn''t retrieve parameter '
                                 + name)
  
          # Extract the string representation of the value, which is after
          # the '*'+name.
          value_str = response[4][0][(len(name)+1):]
  
          # Convert the value string to the appropriate type and return
          # it. Throw an error if it is not supported.
          if tp == bool:
              return (value_str == '1')
          elif tp == int:
              return int(value_str)
          elif tp == float:
              return float(value_str)