pyBROTlib 0.1.4__tar.gz

pybrotlib-0.1.4/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: pyBROTlib
+Version: 0.1.4
+Summary: MQTT interface to BROT telescopes
+Author: Tim-Oliver Husser, Lukas Melzig
+Author-email: Tim-Oliver Husser <thusser@uni-goettingen.de>, Lukas Melzig <lukas.melzig@stud.uni-goettingen.de>
+License-Expression: MIT
+Requires-Dist: aiomqtt>=2.4.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+

pybrotlib-0.1.4/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "pyBROTlib"
+version = "0.1.4"
+description = "MQTT interface to BROT telescopes"
+readme = "README.md"
+authors = [{ name = "Tim-Oliver Husser", email = "thusser@uni-goettingen.de" }, { name = "Lukas Melzig", email = "lukas.melzig@stud.uni-goettingen.de" }]
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = [
+    "aiomqtt>=2.4.0",
+]
+
+[dependency-groups]
+dev = [
+    "mypy>=1.15.0,<2",
+    "black>=25.1.0,<26",
+    "pre-commit>=4.2.0,<5",
+    "flake8>=7.3.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.8,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.setuptools.package-data]
+"pyobs" = ["py.typed"]

pybrotlib-0.1.4/src/pybrotlib/base.py

@@ -0,0 +1,11 @@
+from .transport import Transport
+
+
+class BROTBase:
+    def __init__(self, transport: Transport, telescope_name: str):
+        self._transport = transport
+        self._telemetry = self._transport.telemetry
+        self._telescope_name = telescope_name
+
+
+__all__ = ["BROTBase"]

pybrotlib-0.1.4/src/pybrotlib/brot.py

@@ -0,0 +1,16 @@
+from .dome import BROTDome
+from .focus import BROTFocus
+from .mirrorcovers import BROTMirrorCovers
+from .telescope import BROTTelescope
+from .transport import Transport
+
+
+class BROT:
+    def __init__(self, transport: Transport, telescope_name: str):
+        self.dome = BROTDome(transport, telescope_name)
+        self.focus = BROTFocus(transport, telescope_name)
+        self.mirrorcovers = BROTMirrorCovers(transport, telescope_name)
+        self.telescope = BROTTelescope(transport, telescope_name)
+
+
+__all__ = ["BROT"]

pybrotlib-0.1.4/src/pybrotlib/dome.py

@@ -0,0 +1,87 @@
+from enum import Enum
+
+from .base import BROTBase
+
+
+class DomeShutterStatus(Enum):
+    CLOSED = "closed"
+    MOVING = "moving"
+    OPEN = "open"
+    UNKNOWN = "unknown"
+
+
+class DomeStatus(Enum):
+    PARKED = "parked"
+    ERROR = "error"
+    TRACKING = "tracking"
+    UNKNOWN = "unknown"
+
+
+class BROTDome(BROTBase):
+    @property
+    def shutter(self) -> DomeShutterStatus:
+        match self._telemetry.AUXILIARY.DOME.REALPOS:
+            case 0.0:
+                return DomeShutterStatus.CLOSED
+            case 0.5:
+                return DomeShutterStatus.MOVING
+            case 1.0:
+                return DomeShutterStatus.OPEN
+            case _:
+                return DomeShutterStatus.UNKNOWN
+    
+    @property
+    def in_motion(self) -> bool:
+        return (self._telemetry.AUXILIARY.DOME.REALPOS == 0.5) or (self._telemetry.AUXILIARY.DOME.MOTION_STATE == 1.0)
+    @property
+    def azimuth(self) -> float:
+        return self._telemetry.AUXILIARY.DOME.AZ
+
+    @property
+    def status(self) -> DomeStatus:
+        match self._telemetry.AUXILIARY.DOME.READY_STATE:
+            case 0.0:
+                return DomeStatus.PARKED
+            case -1.0:
+                return DomeStatus.ERROR
+            case 8.0:
+                return DomeStatus.TRACKING
+            case _:
+                return DomeStatus.UNKNOWN
+
+    @property
+    def error_state(self) -> bool:
+        return self._telemetry.AUXILIARY.DOME.ERROR_STATE != 0
+
+    async def open(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command dome_open=1"
+        )
+
+    async def close(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command dome_close=1"
+        )
+
+    async def start_tracking(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command dome_track=1"
+        )
+
+    async def stop_tracking(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command dome_track=0"
+        )
+
+    async def park(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command dome_park=1"
+        )
+
+    async def reset(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command dome_reset=1"
+        )
+
+
+__all__ = ["BROTDome", "DomeStatus", "DomeShutterStatus"]

pybrotlib-0.1.4/src/pybrotlib/focus.py

@@ -0,0 +1,21 @@
+from .base import BROTBase
+
+
+class BROTFocus(BROTBase):
+    @property
+    def position(self) -> float:
+        return self._telemetry.POSITION.INSTRUMENTAL.FOCUS.CURRPOS
+
+    async def set(self, focus: float) -> None:
+        await self._transport.publish(f"{self._telescope_name}/Telescope/SET", f"command focus={focus}")
+
+    @property
+    def powered(self) -> bool:
+        return self._telemetry.POSITION.INSTRUMENTAL.FOCUS.POWER_STATE == 1.0
+
+    @property
+    def referenced(self) -> bool:
+        return self._telemetry.POSITION.INSTRUMENTAL.FOCUS.REFERENCED == 1.0
+
+
+__all__ = ["BROTFocus"]

pybrotlib-0.1.4/src/pybrotlib/mirrorcovers.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+from .base import BROTBase
+
+
+class MirrorCoverStatus(Enum):
+    CLOSED = "closed"
+    MOVING = "moving"
+    OPEN = "open"
+    UNKNOWN = "unknown"
+
+
+class BROTMirrorCovers(BROTBase):
+    @property
+    def status(self) -> MirrorCoverStatus:
+        match self._telemetry.AUXILIARY.COVER.REALPOS:
+            case 0.0:
+                return MirrorCoverStatus.CLOSED
+            case 0.5:
+                return MirrorCoverStatus.MOVING
+            case 1.0:
+                return MirrorCoverStatus.OPEN
+            case _:
+                return MirrorCoverStatus.UNKNOWN

pybrotlib-0.1.4/src/pybrotlib/mqtttransport.py

@@ -0,0 +1,70 @@
+from typing import get_type_hints
+from aiomqtt import Client, Message  # type: ignore
+
+from .transport import Transport
+
+
+class MQTTTransport(Transport):
+    def __init__(self, host: str, port: int):
+        super().__init__()
+
+        self.host = host
+        self.port = port
+
+    def __str__(self) -> str:
+        return f"MQTT(host={self.host}, port={self.port})"
+
+    async def publish(self, topic: str, message: str) -> None:
+        async with Client(self.host, self.port) as client:
+            await client.publish(topic, payload=message.encode("utf-8"))
+
+    async def run(self) -> None:
+        async with Client(self.host, self.port) as client:
+            self._connected = True
+            await client.subscribe("#")
+            async for message in client.messages:
+                await self._process_message(message)
+
+    async def _process_message(self, msg: Message) -> None:
+        # Telemetry handling
+        if "Telemetry" in msg.topic.value:
+            # we only want bytes...
+            if not isinstance(msg.payload, bytes):
+                return
+
+            # analyse message
+            key, value = msg.payload.decode("utf-8").split(" ")[1].split("=")
+            s = key.upper().split(".")
+            obj = self.telemetry
+
+            # dict with ALL telemetry
+            self.data[key] = str(value)
+
+            # find object in telemetry tree
+            for token in s[:-1]:
+                if hasattr(obj, token):
+                    obj = getattr(obj, token)
+                else:
+                    print("Unknown variable:", key)
+                    return
+
+            # does it exist?
+            val: bool | int | float | str
+            if hasattr(obj, s[-1]):
+                typ = get_type_hints(obj)[s[-1]]
+                if typ == bool:
+                    val = value.lower() == "true"
+                elif typ == int:
+                    val = int(value)
+                elif typ == float:
+                    val = float(value)
+                else:
+                    val = value
+                setattr(obj, s[-1], val)
+
+        if "Log" in msg.topic.value:
+            pass
+            # payload = str(msg.payload)[2:-2].split(' message="')
+            # log_message = payload[1]
+            # log_level = payload[0].split("level=")[1]
+            # self.logMessageReceived.emit(log_level, log_message)

pybrotlib-0.1.4/src/pybrotlib/telemetry.py

@@ -0,0 +1,161 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class TelescopeInfo:
+    NAME: str = "Unknown"
+    DIAMETER: float = 0.0
+    CABINET: str = "Unknown"
+    MANUFACTURER: str = "Unknown"
+
+
+@dataclass
+class TelescopeConfig:
+    CAPABILITIES: int = 0
+    MOUNTOPTIONS: str = "Unknown"
+    MOUNT: str = "Unknown"
+
+
+@dataclass
+class TelescopeStatus:
+    GLOBAL: int = 0
+
+
+@dataclass
+class Telescope:
+    READY_STATE: float = 0.0
+    MOTION_STATE: float = 0.0
+    INFO: TelescopeInfo = field(default_factory=TelescopeInfo)
+    CONFIG: TelescopeConfig = field(default_factory=TelescopeConfig)
+    STATUS: TelescopeStatus = field(default_factory=TelescopeStatus)
+
+
+@dataclass
+class ObjectInstrumental:
+    RA: float = 0.0
+    DEC: float = 0.0
+    HA: float = 0.0
+
+
+@dataclass
+class ObjectHorizontal:
+    ALT: float = 0.0
+    AZ: float = 0.0
+
+
+@dataclass
+class ObjectEquatorial:
+    EPOCH: str = "Unknown"
+    EQUINOX: str = "Unknown"
+    RA_PM: float = 0.0
+    DEC_PM: float = 0.0
+    RA_RATE: float = 0.0
+    DEC_RATE: float = 0.0
+    RA: float = 0.0
+    DEC: float = 0.0
+    HA: float = 0.0
+
+
+@dataclass
+class Object:
+    INSTRUMENTAL: ObjectInstrumental = field(default_factory=ObjectInstrumental)
+    HORIZONTAL: ObjectHorizontal = field(default_factory=ObjectHorizontal)
+    EQUATORIAL: ObjectEquatorial = field(default_factory=ObjectEquatorial)
+
+
+@dataclass
+class PointingOffsets:
+    HA: float = 0.0
+    DEC: float = 0.0
+    ALT: float = 0.0
+    AZ: float = 0.0
+
+
+@dataclass
+class Pointing:
+    OFFSETS: PointingOffsets = field(default_factory=PointingOffsets)
+    SLEWTIME: float = 0.0
+
+
+@dataclass
+class PositionLocal:
+    SIDEREAL_TIME: float = 0.0
+    JD: float = 0.0
+    LATITUDE: float = 0.0
+    LONGITUDE: float = 0.0
+    HEIGHT: float = 0.0
+
+
+@dataclass
+class PositionAxis:
+    POWER_STATE: float = 0.0
+    ERROR_STATE: str = ""
+    MOTION_STATE: int = 0
+    REFERENCED: float = 0.0
+    REALPOS: float = 0.0
+    CURRPOS: float = 0.0
+    TARGETPOS: float = 0.0
+    CURRSPEED: float = 0.0
+    TARGETDISTANCE: float = 0.0
+    OFFSET: float = 0.0
+
+
+@dataclass
+class PositionInstrumental:
+    HA: PositionAxis = field(default_factory=PositionAxis)
+    DEC: PositionAxis = field(default_factory=PositionAxis)
+    ALT: PositionAxis = field(default_factory=PositionAxis)
+    AZ: PositionAxis = field(default_factory=PositionAxis)
+    FOCUS: PositionAxis = field(default_factory=PositionAxis)
+
+
+@dataclass
+class PositionHorizontal:
+    ALT: float = 0.0
+    AZ: float = 0.0
+    DOME: float = 0.0
+
+
+@dataclass
+class PositionEquatorial:
+    RA_J2000: float = 0.0
+    DEC_J2000: float = 0.0
+    HA_J2000: float = 0.0
+
+
+@dataclass
+class Position:
+    LOCAL: PositionLocal = field(default_factory=PositionLocal)
+    INSTRUMENTAL: PositionInstrumental = field(default_factory=PositionInstrumental)
+    HORIZONTAL: PositionHorizontal = field(default_factory=PositionHorizontal)
+    EQUATORIAL: PositionEquatorial = field(default_factory=PositionEquatorial)
+
+
+@dataclass
+class Dome:
+    REALPOS: float = 0.0
+    TARGETPOS: float = 0.0
+    ERROR_STATE: int = 0
+    READY_STATE: float = 0.0
+    MOTION_STATE: float = 0.0
+    AZ: float = 0.0
+
+
+@dataclass
+class Cover:
+    REALPOS: float = 0.0
+
+
+@dataclass
+class Auxiliary:
+    DOME: Dome = field(default_factory=Dome)
+    COVER: Cover = field(default_factory=Cover)
+
+
+@dataclass
+class Telemetry:
+    TELESCOPE: Telescope = field(default_factory=Telescope)
+    OBJECT: Object = field(default_factory=Object)
+    POINTING: Pointing = field(default_factory=Pointing)
+    POSITION: Position = field(default_factory=Position)
+    AUXILIARY: Auxiliary = field(default_factory=Auxiliary)

pybrotlib-0.1.4/src/pybrotlib/telescope.py

@@ -0,0 +1,186 @@
+from enum import Enum
+from typing import Any
+
+from .base import BROTBase
+
+
+class TelescopeStatus(Enum):
+    PARKED = "parked"
+    ONLINE = "online"
+    ERROR = "error"
+    INITPARK = "initpark"
+
+
+class GlobalTelescopeStatus(Enum):
+    NOTELESCOPE = "notelescope"
+    OPERATIONAL = "operational"
+    PANIC = "panic"
+    ERROR = "error"
+    WARNING = "warning"
+    INFO = "info"
+    UNKNOWN = "unknown"
+
+
+class BROTAxis(BROTBase):
+    def __init__(self, name: str, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self._axis_name = name
+
+    @property
+    def error_state(self) -> int:
+        return int(
+            getattr(self._telemetry.POSITION.INSTRUMENTAL, self._axis_name).ERROR_STATE
+        )
+
+
+class BROTTelescope(BROTBase):
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.alt = BROTAxis("ALT", *args, **kwargs)
+        self.az = BROTAxis("AZ", *args, **kwargs)
+        self.ha = BROTAxis("HA", *args, **kwargs)
+        self.dec = BROTAxis("DEC", *args, **kwargs)
+        self.focus = BROTAxis("FOCUS", *args, **kwargs)
+
+    @property
+    def name(self) -> str:
+        return self._telemetry.TELESCOPE.INFO.NAME
+
+    @property
+    def diameter(self) -> float:
+        return self._telemetry.TELESCOPE.INFO.DIAMETER
+
+    @property
+    def cabinet(self) -> str:
+        return self._telemetry.TELESCOPE.INFO.CABINET
+
+    @property
+    def manufacturer(self) -> str:
+        return self._telemetry.TELESCOPE.INFO.MANUFACTURER
+
+    @property
+    def mount_options(self) -> str:
+        return self._telemetry.TELESCOPE.CONFIG.MOUNTOPTIONS
+
+    @property
+    def mount(self) -> str:
+        return self._telemetry.TELESCOPE.CONFIG.MOUNT
+
+    async def track(self, ra: float, dec: float) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", f"command rightascension={ra}"
+        )
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", f"command declination={dec}"
+        )
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command track=1"
+        )
+
+    async def move(self, alt: float, az: float) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", f"command elevation={alt}"
+        )
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", f"command azimuth={az}"
+        )
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command slew=1"
+        )
+
+    @property
+    def offset_ha(self) -> float:
+        return self._telemetry.POSITION.INSTRUMENTAL.HA.OFFSET * 3600.0
+
+    async def set_offset_ha(self, offset: float) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET",
+            f"command hourangleoffset={offset/3600.}",
+        )
+
+    @property
+    def offset_dec(self) -> float:
+        return self._telemetry.POSITION.INSTRUMENTAL.DEC.OFFSET * 3600.0
+
+    async def set_offset_dec(self, offset: float) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET",
+            f"command declinationoffset={offset/3600.}",
+        )
+
+    @property
+    def offset_alt(self) -> float:
+        return self._telemetry.POSITION.INSTRUMENTAL.ALT.OFFSET * 3600.0
+
+    async def set_offset_alt(self, offset: float) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET",
+            f"command elevationoffset={offset/3600.}",
+        )
+
+    @property
+    def offset_az(self) -> float:
+        return self._telemetry.POSITION.INSTRUMENTAL.AZ.OFFSET * 3600.0
+
+    async def set_offset_az(self, offset: float) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET",
+            f"command azimuthoffset={offset/3600.}",
+        )
+
+    @property
+    def status(self) -> TelescopeStatus:
+        match self._telemetry.TELESCOPE.READY_STATE:
+            case 0.0:
+                return TelescopeStatus.PARKED
+            case 1.0:
+                return TelescopeStatus.ONLINE
+            case -1.0:
+                return TelescopeStatus.ERROR
+            case _:
+                return TelescopeStatus.INITPARK
+
+    @property
+    def global_status(self) -> GlobalTelescopeStatus:
+        match self._telemetry.TELESCOPE.STATUS.GLOBAL:
+            case -1.0:
+                return GlobalTelescopeStatus.NOTELESCOPE
+            case 0.0:
+                return GlobalTelescopeStatus.OPERATIONAL
+            case 1.0:
+                return GlobalTelescopeStatus.PANIC
+            case 2.0:
+                return GlobalTelescopeStatus.ERROR
+            case 4.0:
+                return GlobalTelescopeStatus.WARNING
+            case 8.0:
+                return GlobalTelescopeStatus.INFO
+            case _:
+                return GlobalTelescopeStatus.UNKNOWN
+
+    @property
+    def initpark(self) -> float:
+        return self._telemetry.TELESCOPE.READY_STATE * 100.0
+
+    async def power_on(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command power=true"
+        )
+
+    async def stop(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command stop=TRUE"
+        )
+
+    async def park(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command park=true"
+        )
+
+    async def reset(self) -> None:
+        await self._transport.publish(
+            f"{self._telescope_name}/Telescope/SET", "command reset=1"
+        )
+
+
+__all__ = ["BROTTelescope", "TelescopeStatus", "GlobalTelescopeStatus"]

pybrotlib-0.1.4/src/pybrotlib/transport.py

@@ -0,0 +1,24 @@
+from abc import ABCMeta, abstractmethod
+from typing import Any
+
+from .telemetry import Telemetry
+
+
+class Transport(metaclass=ABCMeta):
+    def __init__(self) -> None:
+        super().__init__()
+        self.data: dict[str, Any] = {}
+        self.telemetry = Telemetry()
+        self._connected = False
+
+    @abstractmethod
+    async def run(self) -> None:
+        pass
+
+    @abstractmethod
+    async def publish(self, topic: str, message: str) -> None:
+        pass
+
+    @property
+    def connected(self) -> bool:
+        return self._connected