def _send_command(self, command, immediate=False, timeout=1.0,
                      check_echo=None):
        """ Send a single command to the drive after sanitizing it.

        Takes a single given `command`, sanitizes it (strips out
        comments, extra whitespace, and newlines), sends the command to
        the drive, and returns the sanitized command. The validity of
        the command is **NOT** checked.

        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 : number, optional
            Optional timeout in seconds to use to get the command right
            when we are doing echo checking. A negative value or
            ``None`` indicates that the an infinite timeout should be
            used.
        check_echo : bool or None, optional
            Whether the echoing of the command as it is being written to
            the drive should be used to correct mistakes in what the
            drive is seeing, or whether the default set when the
            instance of this class was created should be used
            (``None``).

        Returns
        -------
        sanitized_command : str
            The sanitized command that was sent to the drive.

        """
        # Use the default echo checking if None was given.
        if check_echo is None:
            check_echo = self._check_echo

        # Convert to bytes and then strip comments, whitespace, and
        # newlines.
        if sys.hexversion >= 0x03000000:
            c = bytes(command, encoding='ASCII')
        else:
            c = command
        c = c.split(b';')[0].strip()

        # If the command is supposed to be immediate, insure that it
        # starts with an '!'.
        if immediate and not c.startswith(b'!'):
            c = b'!' + c

        # Read out any junk on the serial port before we start.
        self._ser.read(self._ser.inWaiting())

        # The command needs to be written a character at a time with
        # pauses between them to make sure nothing gets lost or
        # corrupted. This is a simple loop if we are not checking the
        # echo. If we are, it is more complicated.
        if not check_echo:
            for i in range(0, len(c)):
                self._ser.write(bytes([c[i]]))
                time.sleep(0.01)
        else:
            # Infinite timeouts need to be converted to None. Finite
            # ones need to be checked to make sure they are not too big,
            # which is threading.TIMEOUT_MAX on Python 3.x and not
            # specified on Python 2.x (lets use a week).
            if timeout is None or timeout <= 0:
                timeout = None
            else:
                if sys.hexversion >= 0x03000000:
                    maxtimeout = threading.TIMEOUT_MAX
                else:
                    maxtimeout = 7*24*3600
                timeout = min(timeout, maxtimeout)

            # A timer will be made that takes timeout to finish. Then,
            # it is a matter of checking whether it is alive or not to
            # know whether the timeout was exceeded or not. Then, the
            # timer is started.
            tm = threading.Timer(timeout, lambda : None)
            tm.start()

            # Each character needs to be written one by one while the
            # echo is collected. If any mistakes occur, they need to be
            # corrected with backspaces b'\x08'. The echo starts out
            # empty. We go until either the echo is identical to the
            # command or the timeout is exceeded.
            echo = b''
            while c != echo and tm.is_alive():
                # If there are no mistakes, then echo will be the
                # beginning of c meaning the next character can be
                # written. Otherwise, there is a mistake and a backspace
                # needs to be written.
                if c.startswith(echo):
                    self._ser.write(bytes([c[len(echo)]]))
                else:
                    self._ser.write(b'\x08')

                # Pause for a bit to make sure nothing gets lost. Then
                # read the drive's output add it to the echo.
                time.sleep(0.01)
                echo += self._ser.read(self._ser.inWaiting())

                # All backspaces in echo need to be processed. Each
                # backspace deletes itself and the character before it
                # (if any).
                while b'\x08' in echo:
                    index = echo.index(b'\x08')
                    if index == 0:
                        echo = echo[1:]
                    else:
                        echo = echo[0:(index-1)] + echo[(index+1):]

            # Turn off the timer in the case that it is still running
            # (command completely written before timeout).
            tm.cancel()

        # Write the carriage return to enter the command and then return
        # the sanitized command.
        self._ser.write(b'\r')
        if sys.hexversion >= 0x03000000:
            return c.decode(errors='replace')
        else:
            return c
Send a single command to the drive after sanitizing it.

        Takes a single given `command`, sanitizes it (strips out
        comments, extra whitespace, and newlines), sends the command to
        the drive, and returns the sanitized command. The validity of
        the command is **NOT** checked.

        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 : number, optional
            Optional timeout in seconds to use to get the command right
            when we are doing echo checking. A negative value or
            ``None`` indicates that the an infinite timeout should be
            used.
        check_echo : bool or None, optional
            Whether the echoing of the command as it is being written to
            the drive should be used to correct mistakes in what the
            drive is seeing, or whether the default set when the
            instance of this class was created should be used
            (``None``).

        Returns
        -------
        sanitized_command : str
            The sanitized command that was sent to the drive.