docs: def send_command(self, command, immediate=False, timeout=1.0,
                       max_retries=0, eor=('\n', '\n- ')):
          """ Sends a single command to the drive and returns output.
  
          Takes a single given `command`, sanitizes it, sends it to the
          drive, reads the response, and returns the processed response.
          The command is first sanitized by removing comments, extra
          whitespace, and newline characters. If `immediate` is set, the
          command is made to be an immediate command. Note, the command is
          **NOT** checked for validity. If the drive returns an error, the
          command is re-executed up to `max_tries` more times. The
          response from the final execution is processed and returned. The
          response from the drive is broken down into the echoed command
          (drive echoes it back), any error returned by the drive (leading
          '*' is stripped), and the different lines of the response; which
          are all returned.
  
          Parameters
          ----------
          command : str
              The command to send to the Gemini drive.
          immediate : bool, optional
              Whether to make it so the command is executed immediately or
              not.
          timeout : float or None, 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.
          eor : str or iterable of str, optional
              ``str`` or an iterable of ``str`` that denote the allowed
              End Of Response. For most commands, it should be
              ``('\\n', '\\n- ')``, but for running a program, it should
              be ``'*END\\n'``. The default is ``('\\n', '\\n- ')``.
  
          Returns
          -------
          output : list
              A 5-element ``list``. The elements, in order, are the
              sanitized command (``str``), the full response (``str``),
              the echoed command (``str``), any error response (``None``
              if none, or the ``str`` of the error), and the lines of the
              response that are not the echo or error line (``list`` of
              ``str`` with newlines stripped).
  
          See Also
          --------
          send_commands : Send multiple commands.
  
          Examples
          --------
  
          Simple command energizing the motor with no response and no
          errors.
  
          >>> from GeminiMotorDrive.drivers import ASCII_RS232
          >>> ar = ASCII_RS232('/dev/ttyS1')
          >>> ar.send_command('DRIVE1', immediate=False, timeout=1.0)
          ['DRIVE1', 'DRIVE1\\r\\r\\n', 'DRIVE1', None, []]
  
          Same command but made immediate.
  
          >>> from GeminiMotorDrive.drivers import ASCII_RS232
          >>> ar = ASCII_RS232('/dev/ttyS1')
          >>> ar.send_command('DRIVE1', immediate=True, timeout=1.0)
          ['!DRIVE1', '!DRIVE1\\r\\r\\n', '!DRIVE1', None, []]
  
          Same command with a typo.
  
          >>> from GeminiMotorDrive.drivers import ASCII_RS232
          >>> ar = ASCII_RS232('/dev/ttyS1')
          >>> ar.send_command('DRIV1', immediate=False, timeout=1.0)
          ['DRIV1', 'DRIV1\\r*UNDEFINED_LABEL\\r\\r\\n', 'DRIV1',
           'UNDEFINED_LABEL', []]
  
          Simple command asking whether the motor is energized or not.
  
          >>> from GeminiMotorDrive.drivers import ASCII_RS232
          >>> ar = ASCII_RS232('/dev/ttyS1')
          >>> ar.send_command('DRIVE', immediate=False, timeout=1.0)
          ['DRIVE', 'DRIVE\\r*DRIVE1\\r\\r\\n', 'DRIVE', None,
           ['*DRIVE1']]
  
          """
          # Execute the command till it either doesn't have an error or
          # the maximum number of retries is exceeded.
          for i in range(0, max_retries+1):
              # Send the command and stuff the sanitized version in a
              # list. Then process the response and add it to the list.
              response = [self._send_command(command,
                          immediate=immediate)]
              output = self._get_response(timeout=timeout, eor=eor)
              # If echo checking was done, the echo was already grabbed,
              # is identical to the command, and needs to be placed back
              # in front of the output so that it can be processed
              # properly.
              if self._check_echo:
                  output = response[0] + output
              response.extend(self._process_response(output))
              # We are done if there is no error.
              if not self.command_error(response):
                  break
              # Put in a slight pause so the drive has a bit of breathing
              # time between retries.
              time.sleep(0.25)
          return response