citrascope 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

citrascope/hardware/indi_adapter.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import time
 from pathlib import Path
@@ -10,7 +11,11 @@ from pixelemon.optics._base_optical_assembly import BaseOpticalAssembly
 from pixelemon.sensors import IMX174
 from pixelemon.sensors._base_sensor import BaseSensor
 
-from citrascope.hardware.abstract_astro_hardware_adapter import AbstractAstroHardwareAdapter
+from citrascope.hardware.abstract_astro_hardware_adapter import (
+    AbstractAstroHardwareAdapter,
+    ObservationStrategy,
+    SettingSchemaEntry,
+)
 
 
 # The IndiClient class which inherits from the module PyIndi.BaseClient class
@@ -28,14 +33,64 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
     _alignment_offset_ra: float = 0.0
     _alignment_offset_dec: float = 0.0
 
-    def __init__(self, CITRA_LOGGER, host: str, port: int):
-        super(IndiAdapter, self).__init__()
-        self.logger = CITRA_LOGGER
-        self.logger.debug("creating an instance of IndiClient")
-        self.host = host
-        self.port = port
-
-        TetraSolver.high_memory()
+    def __init__(self, logger: logging.Logger, images_dir: Path, **kwargs):
+        PyIndi.BaseClient.__init__(self)
+        AbstractAstroHardwareAdapter.__init__(self, images_dir=images_dir)
+        self.logger: logging.Logger = logger
+        if self.logger:
+            self.logger.debug("creating an instance of IndiClient")
+        self.host = kwargs.get("host", "localhost")
+        self.port = int(kwargs.get("port", 7624))
+        self.telescope_name = kwargs.get("telescope_name", "")
+        self.camera_name = kwargs.get("camera_name", "")
+
+        # TetraSolver.high_memory()
+
+    @classmethod
+    def get_settings_schema(cls) -> list[SettingSchemaEntry]:
+        """
+        Return a schema describing configurable settings for the INDI adapter.
+        """
+        return [
+            {
+                "name": "host",
+                "friendly_name": "INDI Server Host",
+                "type": "str",
+                "default": "localhost",
+                "description": "INDI server hostname or IP address",
+                "required": True,
+                "placeholder": "localhost or 192.168.1.100",
+            },
+            {
+                "name": "port",
+                "friendly_name": "INDI Server Port",
+                "type": "int",
+                "default": 7624,
+                "description": "INDI server port",
+                "required": True,
+                "placeholder": "7624",
+                "min": 1,
+                "max": 65535,
+            },
+            {
+                "name": "telescope_name",
+                "friendly_name": "Telescope Device Name",
+                "type": "str",
+                "default": "",
+                "description": "Name of the telescope device (leave empty to auto-detect)",
+                "required": False,
+                "placeholder": "Telescope Simulator",
+            },
+            {
+                "name": "camera_name",
+                "friendly_name": "Camera Device Name",
+                "type": "str",
+                "default": "",
+                "description": "Name of the camera device (leave empty to auto-detect)",
+                "required": False,
+                "placeholder": "CCD Simulator",
+            },
+        ]
 
     def newDevice(self, d):
         """Emmited when a new device is created from INDI server."""
@@ -80,8 +135,7 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
 
                 # if there's a task underway, save the image to a file
                 if self._current_task_id != "":
-                    os.makedirs("images", exist_ok=True)
-                    self._last_saved_filename = f"images/citra_task_{self._current_task_id}_image.fits"
+                    self._last_saved_filename = str(self.images_dir / f"citra_task_{self._current_task_id}_image.fits")
                     for b in blobProperty:
                         with open(self._last_saved_filename, "wb") as f:
                             f.write(b.getblobdata())
@@ -120,7 +174,57 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
 
     def connect(self) -> bool:
         self.setServer(self.host, self.port)
-        return self.connectServer()
+        connected = self.connectServer()
+
+        if not connected:
+            self.logger.error("Failed to connect to INDI server")
+            return False
+
+        time.sleep(1)  # Give server time to enumerate devices
+
+        # Auto-select telescope if name provided, or auto-detect first telescope
+        if self.telescope_name:
+            device_list = self.list_devices()
+            if self.telescope_name not in device_list:
+                self.logger.error(f"Could not find configured telescope ({self.telescope_name}) on INDI server.")
+                return False
+
+            if not self.select_telescope(self.telescope_name):
+                self.logger.error(f"Failed to select telescope: {self.telescope_name}")
+                return False
+            self.logger.info(f"Found and connected to telescope: {self.telescope_name}")
+        else:
+            # Auto-detect: try to find and select first telescope device
+            telescope_found = self._auto_detect_telescope()
+            if not telescope_found:
+                self.logger.warning(
+                    "No telescope_name configured and auto-detection failed. "
+                    "Please configure telescope_name in adapter_settings."
+                )
+                # Don't return False here - allow operation to continue for cameras-only setups
+
+        # Auto-select camera if name provided, or auto-detect first camera
+        if self.camera_name:
+            device_list = self.list_devices()
+            if self.camera_name not in device_list:
+                self.logger.error(f"Could not find configured camera ({self.camera_name}) on INDI server.")
+                return False
+
+            if not self.select_camera(self.camera_name):
+                self.logger.error(f"Failed to select camera: {self.camera_name}")
+                return False
+            self.logger.info(f"Found and connected to camera: {self.camera_name}")
+        else:
+            # Auto-detect: try to find and select first camera device
+            camera_found = self._auto_detect_camera()
+            if not camera_found:
+                self.logger.warning(
+                    "No camera_name configured and auto-detection failed. "
+                    "Please configure camera_name in adapter_settings."
+                )
+                # Don't return False here - allow operation to continue
+
+        return True
 
     def list_devices(self):
         names = []
@@ -128,33 +232,203 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
             names.append(device.getDeviceName())
         return names
 
+    def _auto_detect_telescope(self) -> bool:
+        """Auto-detect and select the first available telescope device.
+
+        Returns:
+            True if a telescope was found and selected, False otherwise.
+        """
+        devices = self.getDevices()
+        for device in devices:
+            device_name = device.getDeviceName()
+            # Check if device has EQUATORIAL_EOD_COORD property (indicates it's a telescope)
+            # We need to wait a bit for properties to be available
+            for attempt in range(5):
+                telescope_radec = device.getNumber("EQUATORIAL_EOD_COORD")
+                if telescope_radec:
+                    self.logger.info(f"Auto-detected telescope device: {device_name}")
+                    if self.select_telescope(device_name):
+                        return True
+                    break
+                time.sleep(0.5)
+
+        self.logger.debug("No telescope device auto-detected")
+        return False
+
+    def _auto_detect_camera(self) -> bool:
+        """Auto-detect and select the first available camera device.
+
+        Returns:
+            True if a camera was found and selected, False otherwise.
+        """
+        devices = self.getDevices()
+        for device in devices:
+            device_name = device.getDeviceName()
+            # Check if device has CCD_EXPOSURE property (indicates it's a camera)
+            # We need to wait a bit for properties to be available
+            for attempt in range(5):
+                ccd_exposure = device.getNumber("CCD_EXPOSURE")
+                if ccd_exposure:
+                    self.logger.info(f"Auto-detected camera device: {device_name}")
+                    if self.select_camera(device_name):
+                        return True
+                    break
+                time.sleep(0.5)
+
+        self.logger.debug("No camera device auto-detected")
+        return False
+
     def select_telescope(self, device_name: str) -> bool:
+        """Select a specific telescope by name and wait for it to be ready.
+
+        Args:
+            device_name: Name of the telescope device to select
+
+        Returns:
+            True if telescope was found and is ready, False otherwise
+        """
         devices = self.getDevices()
         for device in devices:
             if device.getDeviceName() == device_name:
                 self.our_scope = device
-                return True
+                self.logger.debug(f"Found telescope device: {device_name}")
+
+                # Connect the telescope device if not already connected
+                connect_prop = device.getSwitch("CONNECTION")
+                if connect_prop:
+                    if not device.isConnected():
+                        self.logger.info(f"Connecting telescope device: {device_name}")
+                        connect_prop[0].setState(PyIndi.ISS_ON)  # CONNECT
+                        connect_prop[1].setState(PyIndi.ISS_OFF)  # DISCONNECT
+                        self.sendNewSwitch(connect_prop)
+                        time.sleep(1)  # Give device time to connect
+                    else:
+                        self.logger.debug(f"Telescope device {device_name} already connected")
+                else:
+                    self.logger.warning(f"Telescope device {device_name} has no CONNECTION property")
+
+                # Wait for EQUATORIAL_EOD_COORD property to be available
+                for attempt in range(10):
+                    telescope_radec = device.getNumber("EQUATORIAL_EOD_COORD")
+                    if telescope_radec and len(telescope_radec) >= 2:
+                        self.logger.info(f"Telescope {device_name} is ready (EQUATORIAL_EOD_COORD available)")
+                        return True
+                    self.logger.debug(f"Waiting for EQUATORIAL_EOD_COORD property... ({attempt + 1}/10)")
+                    time.sleep(0.5)
+
+                self.logger.error(
+                    f"Telescope {device_name} selected but EQUATORIAL_EOD_COORD property not available. "
+                    f"Device may not be fully initialized."
+                )
+                return False
+
+        self.logger.error(f"Telescope device '{device_name}' not found in INDI device list")
         return False
 
     def disconnect(self):
         self.disconnectServer()
 
+    def is_telescope_connected(self) -> bool:
+        """Check if telescope is connected and responsive."""
+        if not self.isServerConnected():
+            return False
+        if not hasattr(self, "our_scope") or self.our_scope is None:
+            return False
+        # Check if we can read the telescope position (indicates it's working)
+        try:
+            telescope_radec = self.our_scope.getNumber("EQUATORIAL_EOD_COORD")
+            return telescope_radec is not None and len(telescope_radec) >= 2
+        except Exception:
+            return False
+
+    def is_camera_connected(self) -> bool:
+        """Check if camera is connected and responsive."""
+        if not self.isServerConnected():
+            return False
+        if not hasattr(self, "our_camera") or self.our_camera is None:
+            return False
+        # Check if camera is connected via INDI
+        try:
+            if not self.our_camera.isConnected():
+                return False
+            # Check if we can read the exposure property (indicates it's working)
+            ccd_exposure = self.our_camera.getNumber("CCD_EXPOSURE")
+            return ccd_exposure is not None
+        except Exception:
+            return False
+
     def _do_point_telescope(self, ra: float, dec: float):
         """Hardware-specific implementation to point the telescope to the specified RA/Dec coordinates."""
+        # Check if connected to INDI server first
+        if not self.isServerConnected():
+            self.logger.debug("Not connected to INDI server")
+            return
+
+        # Check if telescope is selected
+        if not hasattr(self, "our_scope") or self.our_scope is None:
+            self.logger.error(
+                "No telescope selected. Please configure 'telescope_name' in adapter_settings, "
+                "or ensure your INDI server has a telescope device with EQUATORIAL_EOD_COORD property."
+            )
+            return
+
+        # Get the property
         telescope_radec = self.our_scope.getNumber("EQUATORIAL_EOD_COORD")
+
+        # Check if property exists and is valid
+        if not telescope_radec:
+            self.logger.error("EQUATORIAL_EOD_COORD property not found on telescope")
+            return
+
+        # Check if property is ready (not busy)
+        if telescope_radec.getState() == PyIndi.IPS_BUSY:
+            self.logger.warning("Telescope is currently busy, waiting for it to be ready...")
+            # Could add a wait loop here if needed
+
+        # Check if property has the expected number of elements
+        if len(telescope_radec) < 2:
+            self.logger.error(f"EQUATORIAL_EOD_COORD has {len(telescope_radec)} elements, expected 2")
+            return
+
         new_ra = float(ra)
         new_dec = float(dec)
         telescope_radec[0].setValue(new_ra)  # RA in hours
         telescope_radec[1].setValue(new_dec)  # DEC in degrees
+
         try:
             self.sendNewNumber(telescope_radec)
+            self.logger.info(f"Sent telescope coordinates: RA={new_ra}h, DEC={new_dec}°")
         except Exception as e:
             self.logger.error(f"Error sending new RA/DEC to telescope: {e}")
             return
 
     def get_telescope_direction(self) -> tuple[float, float]:
         """Read the current telescope direction (RA degrees, DEC degrees)."""
+        # Check if connected to INDI server first
+        if not self.isServerConnected():
+            self.logger.debug("Not connected to INDI server")
+            return (0.0, 0.0)
+
+        # Check if telescope is selected
+        if not hasattr(self, "our_scope") or self.our_scope is None:
+            self.logger.error(
+                "No telescope selected. Please configure 'telescope_name' in adapter_settings, "
+                "or ensure your INDI server has a telescope device with EQUATORIAL_EOD_COORD property."
+            )
+            return (0.0, 0.0)
+
         telescope_radec = self.our_scope.getNumber("EQUATORIAL_EOD_COORD")
+
+        if not telescope_radec:
+            self.logger.error("EQUATORIAL_EOD_COORD property not found on telescope")
+            self.logger.error("Could not read telescope coordinates")
+            return (0.0, 0.0)
+
+        if len(telescope_radec) < 2:
+            self.logger.error(f"EQUATORIAL_EOD_COORD has {len(telescope_radec)} elements, expected 2")
+            self.logger.error("Could not read telescope coordinates")
+            return (0.0, 0.0)
+
         self.logger.debug(
             f"Telescope currently pointed to RA: {telescope_radec[0].value * 15.0} degrees, DEC: {telescope_radec[1].value} degrees"
         )
@@ -162,7 +436,18 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
 
     def telescope_is_moving(self) -> bool:
         """Check if the telescope is currently moving."""
+        # Check if connected to INDI server first
+        if not self.isServerConnected():
+            return False
+
+        if not hasattr(self, "our_scope") or self.our_scope is None:
+            return False
+
         telescope_radec = self.our_scope.getNumber("EQUATORIAL_EOD_COORD")
+
+        if not telescope_radec:
+            return False
+
         return telescope_radec.getState() == PyIndi.IPS_BUSY
 
     def select_camera(self, device_name: str) -> bool:
@@ -172,17 +457,153 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
             if device.getDeviceName() == device_name:
                 self.our_camera = device
                 self.setBLOBMode(PyIndi.B_ALSO, device_name, None)
+
+                # Connect the camera device if not already connected
+                connect_prop = device.getSwitch("CONNECTION")
+                if connect_prop:
+                    if not device.isConnected():
+                        self.logger.info(f"Connecting camera device: {device_name}")
+                        self._set_switch(device, "CONNECTION", "CONNECT")
+                        time.sleep(2)  # Give device time to connect
+                    else:
+                        self.logger.debug(f"Camera device {device_name} already connected")
+
+                # Configure camera parameters
+                self._configure_camera_params()
+
                 return True
         return False
 
+    def _configure_camera_params(self):
+        """Initialize camera parameters to match EKOS behavior."""
+        if not hasattr(self, "our_camera") or self.our_camera is None:
+            return
+
+        self._set_switch(self.our_camera, "CONNECTION", "CONNECT")
+        self._set_switch(self.our_camera, "CCD_FRAME_TYPE", "FRAME_LIGHT")
+        self._set_switch(self.our_camera, "UPLOAD_MODE", "UPLOAD_CLIENT")
+        self._set_switch(
+            self.our_camera, "CCD_TRANSFER_FORMAT", "FORMAT_FITS"
+        )  # No ISwitch '' in CCD Simulator.CCD_TRANSFER_FORMAT..?
+        self._set_switch(self.our_camera, "CCD_COMPRESSION", "INDI_DISABLED")
+
+        self._set_numbers(
+            self.our_camera,
+            "CCD_BINNING",
+            {
+                "HOR_BIN": 1,
+                "VER_BIN": 1,
+            },
+        )
+
+        # Get CCD_INFO to find max dimensions
+        ccd_info = self.our_camera.getNumber("CCD_INFO")
+        max_x = None
+        max_y = None
+        if ccd_info:
+            for item in ccd_info:
+                if item.getName() == "CCD_MAX_X":
+                    max_x = item.value
+                elif item.getName() == "CCD_MAX_Y":
+                    max_y = item.value
+
+        if max_x and max_y:
+            self._set_numbers(
+                self.our_camera,
+                "CCD_FRAME",
+                {
+                    "X": 0,
+                    "Y": 0,
+                    "WIDTH": max_x,
+                    "HEIGHT": max_y,
+                },
+            )
+
+    def _set_switch(self, device, property_name: str, switch_name: str) -> bool:
+        svp = device.getSwitch(property_name)
+        if svp is None:
+            return False
+
+        available_names = [item.getName() for item in svp]
+        if switch_name not in available_names:
+            self.logger.warning(f"INDI Switch '{property_name}' only supports {available_names}, not '{switch_name}'")
+            return False
+
+        # Turn everything OFF
+        for item in svp:
+            item.setState(PyIndi.ISS_OFF)
+
+        # Turn the desired one ON
+        matched = False
+        for item in svp:
+            item_name = item.getName()
+            if item_name == switch_name:
+                item.setState(PyIndi.ISS_ON)
+                matched = True
+                break
+
+        if not matched:
+            return False
+
+        # Send updated vector
+        result = self.sendNewSwitch(svp)
+        return True
+
+    def _set_numbers(self, device, property_name: str, values: dict) -> bool:
+        """
+        values: { "ELEMENT_NAME": value, ... }
+        """
+        nvp = device.getNumber(property_name)
+        if nvp is None:
+            return False
+
+        # Map element names → items
+        items = {item.getName(): item for item in nvp}
+
+        # Ensure all requested elements exist
+        for name in values.keys():
+            if name not in items:
+                return False  # or raise
+
+        # Set values
+        for name, val in values.items():
+            items[name].setValue(float(val))
+
+        # Send once
+        result = self.sendNewNumber(nvp)
+        return True
+
     def take_image(self, task_id: str, exposure_duration_seconds=1.0):
         """Capture an image with the currently selected camera."""
 
+        # Check if camera is selected
+        if not hasattr(self, "our_camera") or self.our_camera is None:
+            self.logger.error("No camera selected. Call select_camera() first.")
+            return None
+
+        # Get the CCD_EXPOSURE property
+        ccd_exposure = self.our_camera.getNumber("CCD_EXPOSURE")
+
+        # Check if property exists and is valid
+        if not ccd_exposure:
+            self.logger.error("CCD_EXPOSURE property not found on camera")
+            return None
+
+        # Check if property has at least one element
+        if len(ccd_exposure) < 1:
+            self.logger.error(f"CCD_EXPOSURE has {len(ccd_exposure)} elements, expected at least 1")
+            return None
+
         self.logger.info(f"Taking {exposure_duration_seconds} second exposure...")
         self._current_task_id = task_id
-        ccd_exposure = self.our_camera.getNumber("CCD_EXPOSURE")
-        ccd_exposure[0].setValue(exposure_duration_seconds)
-        self.sendNewNumber(ccd_exposure)
+
+        try:
+            ccd_exposure[0].setValue(exposure_duration_seconds)
+            self.sendNewNumber(ccd_exposure)
+        except Exception as e:
+            self.logger.error(f"Error sending exposure command to camera: {e}")
+            self._current_task_id = ""
+            return None
 
         while self.is_camera_busy() and self._current_task_id != "":
             self.logger.debug("Waiting for camera to finish exposure...")
@@ -194,7 +615,16 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
 
     def is_camera_busy(self) -> bool:
         """Check if the camera is currently busy taking an image."""
+        # Check if camera is selected
+        if not hasattr(self, "our_camera") or self.our_camera is None:
+            return False
+
         ccd_exposure = self.our_camera.getNumber("CCD_EXPOSURE")
+
+        # Check if property exists
+        if not ccd_exposure:
+            return False
+
         return ccd_exposure.getState() == PyIndi.IPS_BUSY
 
     def set_custom_tracking_rate(self, ra_rate: float, dec_rate: float):
@@ -251,6 +681,10 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
             # take alignment exposure
             alignment_filename = self.take_image("alignment", 5.0)
 
+            if alignment_filename is None:
+                self.logger.error("Failed to take alignment image.")
+                return False
+
             # this needs to be made configurable
             sim_ccd = BaseSensor(
                 x_pixel_count=1280,
@@ -288,3 +722,9 @@ class IndiAdapter(PyIndi.BaseClient, AbstractAstroHardwareAdapter):
         except Exception as e:
             self.logger.error(f"Error during alignment: {e}")
             return False
+
+    def get_observation_strategy(self) -> ObservationStrategy:
+        return ObservationStrategy.MANUAL
+
+    def perform_observation_sequence(self, task_id, satellite_data) -> str:
+        raise NotImplementedError