STX: one loop thread at a time

            log.info("STX: Loop started")

    def stop_looping(self):

        """Stop the acquisition loop and wait until the camera is actually idle.

        """Stop the acquisition loop and wait until the loop thread has ended.

        ``looping = False`` only tells the background thread not to

        retrigger — a frame already in flight keeps running. Abort it and

        self.looping = False

        if self.state != 0:

            self.abort()

        deadline = time.time() + self.loop_exposure + 2.0

        while self.state != 0 and time.time() < deadline:

            time.sleep(0.1)

        # Wait for the loop thread itself to end, not just for state 0:

        # the camera can be idle while the thread is still downloading

        # the previous frame, which would then overwrite the new ones.

        thread = self._loop_thread

        if thread is not None:

            thread.join(timeout=self.loop_exposure + self.download_timeout + 5.0)

    def _is_current_loop(self):

        """bool : True if the calling thread is the active loop thread."""

        return self._looping and self._loop_thread is threading.current_thread()

    def _run_loop(self):

        while self._looping:

        # Also stop if a newer loop thread has replaced this one: if the

        # loop is turned off and on again (e.g. to change the binning)

        # while this thread is sleeping, it would otherwise find _looping

        # True again and keep acquiring together with the new one.

        while self._is_current_loop():

            self._start(self.loop_exposure, 1)

            while self._looping and self.ready != 1:

            while self._is_current_loop() and self.ready != 1:

                time.sleep(0.3)

            if self._looping:

            if self._is_current_loop():

                # Consume the buffer (HTTP readout) synchronously, in the same

                # loop that decides when to retrigger — otherwise the next

                # _start() can fire before the camera has left Reading state.

                # actually left Exposing/Reading state yet (ready and state

                # are two independent HTTP polls) — wait for real idle

                # before retriggering, or _start() rejects the next frame.

                while self._looping and self.state != 0:

                while self._is_current_loop() and self.state != 0:

                    time.sleep(0.1)

        log.info("STX: Loop stopped")