NexstarGUI

#! /usr/bin/env python3

import time, subprocess
from QtBinding import QtGui, QtCore, QtSignal, QtSlot
from Nexstar import NexstarHandController, NexstarCoordinateMode, NexstarDeviceId
from enum import Enum

import sys

class NexstarHandControllerConnectionStatus(Enum):
    DISCONNECTED  = 1
    CONNECTING    = 2
    CONNECTED     = 3
    DISCONNECTING = 4

class NexstarHandControllerThread(QtCore.QThread):
    def __init__(self):
        pass

class NexstarHandControllerQt(QtCore.QObject):

    statusChanged = QtSignal()

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

        self._connectionStatus = NexstarHandControllerConnectionStatus.DISCONNECTED
        self._port             = "/dev/ttyUSB2"
        self._controller       = None

        self._model                             = None
        self._version                           = None
        self._location                          = None
        self._time                              = None
        self._alignmentComplete                 = None
        self._gotoInProgress                    = None
        self._positionAltitudeAzimuth           = None
        self._positionRightAscensionDeclination = None

        self._updateStatusTimer = QtCore.QTimer()
        self._updateStatusTimer.timeout.connect(self._updateStatus)
        self._updateStatusTimer.start(20)

    @property
    def port(self):
        return self._port

    @property
    def connectionStatus(self):
        return self._connectionStatus

    @property
    def model(self):
        return self._model

    @property
    def version(self):
        return self._version

    @property
    def location(self):
        return self._location

    @property
    def time(self):
        return self._time

    @property
    def alignmentComplete(self):
        return self._alignmentComplete

    @property
    def gotoInProgress(self):
        return self._gotoInProgress

    @property
    def positionAltitudeAzimuth(self):
        return self._positionAltitudeAzimuth

    @property
    def positionRightAscensionDeclination(self):
        return self._positionRightAscensionDeclination

    @QtSlot()
    def openConnection(self):
        if not (self._connectionStatus == NexstarHandControllerConnectionStatus.DISCONNECTED):
            return

        self._connectionStatus = NexstarHandControllerConnectionStatus.CONNECTING
        self.statusChanged.emit()

        self._controller = NexstarHandController(self._port)

        self._connectionStatus = NexstarHandControllerConnectionStatus.CONNECTED
        self.statusChanged.emit()

        self._updateStatus()

    @QtSlot()
    def closeConnection(self):
        if not (self._connectionStatus == NexstarHandControllerConnectionStatus.CONNECTED):
            return

        self._connectionStatus = NexstarHandControllerConnectionStatus.DISCONNECTING
        self.statusChanged.emit()

        self._controller.close()
        self._controller = None

        self._model                             = None
        self._version                           = None
        self._location                          = None
        self._time                              = None
        self._alignmentComplete                 = None
        self._gotoInProgress                    = None
        self._positionAltitudeAzimuth           = None
        self._positionRightAscensionDeclination = None

        self._connectionStatus = NexstarHandControllerConnectionStatus.DISCONNECTED
        self.statusChanged.emit()

    @QtSlot()
    def _updateStatus(self):

        if not (self._connectionStatus == NexstarHandControllerConnectionStatus.CONNECTED):
            return

        if self._model is None:

            model = self._controller.getModel()
            if model != self._model:
                self._model = model
                self.statusChanged.emit()

        if self._version is None:

            version = self._controller.getVersion()
            if version != self._version:
                self._version = version
                self.statusChanged.emit()

        if self._location is None:

            location = self._controller.getLocation()
            if location != self._location:
                self._location = location
                self.statusChanged.emit()

        time = self._controller.getTime()
        if time != self.time:
            self._time = time
            self.statusChanged.emit()

        alignmentComplete = self._controller.getAlignmentComplete()
        if alignmentComplete != self._alignmentComplete:
            self._alignmentComplete = alignmentComplete
            self.statusChanged.emit()

        gotoInProgress = self._controller.getGotoInProgress()
        if gotoInProgress != self._gotoInProgress:
            self._gotoInProgress = gotoInProgress
            self.statusChanged.emit()

        positionAltitudeAzimuth = self._controller.getPosition(coordinateMode = NexstarCoordinateMode.AZM_ALT)
        if positionAltitudeAzimuth != self._positionAltitudeAzimuth:
            self._positionAltitudeAzimuth = positionAltitudeAzimuth
            self.statusChanged.emit()

        positionRightAscensionDeclination = self._controller.getPosition(coordinateMode = NexstarCoordinateMode.RA_DEC)
        if positionRightAscensionDeclination != self._positionRightAscensionDeclination:
            self._positionRightAscensionDeclination = positionRightAscensionDeclination
            self.statusChanged.emit()

    def slew_variable(self, deviceId, rate):
        if self._controller is not None:
            self._controller.slew_variable(deviceId, rate)

class NexstarWidget(QtGui.QWidget):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        handController = NexstarHandControllerQt()

        layout = QtGui.QGridLayout()

        portLabel = QtGui.QLabel("port")
        layout.addWidget(portLabel, 0, 0)
        portValue = QtGui.QLineEdit()
        layout.addWidget(portValue, 0, 1)

        connectionStatusLabel = QtGui.QLabel("Connection status")
        layout.addWidget(connectionStatusLabel, 1, 0)
        connectionStatusValue = QtGui.QLineEdit()
        layout.addWidget(connectionStatusValue, 1, 1)
        connectionButton = QtGui.QPushButton("Connect")
        layout.addWidget(connectionButton, 1, 2)

        modelLabel = QtGui.QLabel("Model")
        layout.addWidget(modelLabel, 2, 0)
        modelValue = QtGui.QLineEdit()
        modelValue.setReadOnly(True)
        layout.addWidget(modelValue, 2, 1)

        versionLabel = QtGui.QLabel("Version")
        layout.addWidget(versionLabel, 3, 0)
        versionValue = QtGui.QLineEdit()
        versionValue.setReadOnly(True)
        layout.addWidget(versionValue, 3, 1)

        locationLabel = QtGui.QLabel("Location")
        layout.addWidget(locationLabel, 4, 0)
        locationValue = QtGui.QLineEdit()
        locationValue.setReadOnly(True)
        layout.addWidget(locationValue, 4, 1)

        timeLabel = QtGui.QLabel("Time")
        layout.addWidget(timeLabel, 5, 0)
        timeValue = QtGui.QLineEdit()
        timeValue.setReadOnly(True)
        layout.addWidget(timeValue, 5, 1)

        alignmentCompleteLabel = QtGui.QLabel("Alignment complete")
        layout.addWidget(alignmentCompleteLabel, 6, 0)
        alignmentCompleteValue = QtGui.QLineEdit()
        alignmentCompleteValue.setReadOnly(True)
        layout.addWidget(alignmentCompleteValue, 6, 1)

        gotoInProgressLabel = QtGui.QLabel("Goto in progress")
        layout.addWidget(gotoInProgressLabel, 7, 0)
        gotoInProgressValue = QtGui.QLineEdit()
        gotoInProgressValue.setReadOnly(True)
        layout.addWidget(gotoInProgressValue, 7, 1)

        positionAltitudeAzimuthLabel = QtGui.QLabel("Position (ALT/AZ)")
        layout.addWidget(positionAltitudeAzimuthLabel, 8, 0)
        positionAltitudeAzimuthValue = QtGui.QLineEdit()
        positionAltitudeAzimuthValue.setReadOnly(True)
        layout.addWidget(positionAltitudeAzimuthValue, 8, 1)

        positionRightAscensionDeclinationhLabel = QtGui.QLabel("Position (RA/DEC)")
        layout.addWidget(positionRightAscensionDeclinationhLabel, 9, 0)
        positionRightAscensionDeclinationValue = QtGui.QLineEdit()
        positionRightAscensionDeclinationValue.setReadOnly(True)
        layout.addWidget(positionRightAscensionDeclinationValue, 9, 1)

        slewCommandsLabel = QtGui.QLabel("Slew")
        layout.addWidget(slewCommandsLabel, 10, 0)

        slewLeftButton = QtGui.QPushButton("Left")
        layout.addWidget(slewLeftButton, 10, 1)

        slewRightButton = QtGui.QPushButton("Right")
        layout.addWidget(slewRightButton, 11, 1)

        slewUpButton = QtGui.QPushButton("Up")
        layout.addWidget(slewUpButton, 12, 1)

        slewDownButton = QtGui.QPushButton("Down")
        layout.addWidget(slewDownButton, 13, 1)

        slewStopButton = QtGui.QPushButton("Stop")
        layout.addWidget(slewStopButton, 14, 1)

        self.setLayout(layout)

        handController.statusChanged.connect(self._updateHandControllerStatus)
        connectionButton.clicked.connect(self._connectionButtonClicked)

        slewLeftButton .clicked.connect(self._slewLeftButtonClicked)
        slewRightButton.clicked.connect(self._slewRightButtonClicked)
        slewUpButton   .clicked.connect(self._slewUpButtonClicked)
        slewDownButton .clicked.connect(self._slewDownButtonClicked)
        slewStopButton .clicked.connect(self._slewStopButtonClicked)

        self._handController = handController
        self._portValue = portValue
        self._connectionStatusValue = connectionStatusValue
        self._connectionButton = connectionButton

        self._modelValue                             = modelValue
        self._versionValue                           = versionValue
        self._locationValue                          = locationValue
        self._timeValue                              = timeValue
        self._alignmentCompleteValue                 = alignmentCompleteValue
        self._gotoInProgressValue                    = gotoInProgressValue
        self._positionAltitudeAzimuthValue           = positionAltitudeAzimuthValue
        self._positionRightAscensionDeclinationValue = positionRightAscensionDeclinationValue

        self._slewLeftButton  = slewLeftButton
        self._slewRightButton = slewRightButton
        self._slewUpButton    = slewUpButton
        self._slewDownButton  = slewDownButton
        self._slewStopButton  = slewStopButton

        self._updateHandControllerStatus()

    @QtSlot()
    def _updateHandControllerStatus(self):

        port = self._handController.port
        self._portValue.setText(port)

        connectionStatus = self._handController.connectionStatus
        self._connectionStatusValue.setText(connectionStatus.name)

        if connectionStatus in [NexstarHandControllerConnectionStatus.DISCONNECTED, NexstarHandControllerConnectionStatus.CONNECTED]:
            connectionButtonEnabled = True
        else:
            connectionButtonEnabled = False

        self._connectionButton.setEnabled(connectionButtonEnabled)

        connected = (connectionStatus == NexstarHandControllerConnectionStatus.CONNECTED)
        self._slewLeftButton.setEnabled(connected)
        self._slewRightButton.setEnabled(connected)
        self._slewUpButton.setEnabled(connected)
        self._slewDownButton.setEnabled(connected)
        self._slewStopButton.setEnabled(connected)

        if connectionStatus in [NexstarHandControllerConnectionStatus.DISCONNECTED, NexstarHandControllerConnectionStatus.CONNECTING]:
            connectionButtonText = "Connect"
        else:
            connectionButtonText = "Disconnect"

        self._connectionButton.setText(connectionButtonText)

        model = self._handController.model
        if model is None:
            modelValue = "n/a"
        else:
            modelValue = repr(model)

        self._modelValue.setText(modelValue)

        version = self._handController.version
        if version is None:
            versionValue = "n/a"
        else:
            versionValue = "{}.{}".format(version[0], version[1])

        self._versionValue.setText(versionValue)

        location = self._handController.location
        if location is None:
            locationValue  = "n/a"
        else:
            locationValue  = "latitude {:.6f}° ; longitude = {:.6f}°".format(location[0], location[1])

        self._locationValue.setText(locationValue)

        time = self._handController.time
        if time is None:
            timeValue = "n/a"
        else:
            (timestamp, dst) = time
            dstValue = "active" if dst else "inactive"
            timeValue = "{} (Daylight Saving Time: {})".format(timestamp, dstValue)

        print("-->", timeValue)
        self._timeValue.setText(timeValue)

        alignmentComplete = self._handController.alignmentComplete
        if alignmentComplete is None:
            alignmentCompleteValue = "n/a"
        else:
            alignmentCompleteValue = "yes" if alignmentComplete else "no"

        self._alignmentCompleteValue.setText(alignmentCompleteValue)

        gotoInProgress = self._handController.gotoInProgress
        if gotoInProgress is None:
            gotoInProgressValue = "n/a"
        else:
            gotoInProgressValue = "yes" if gotoInProgress else "no"

        self._gotoInProgressValue.setText(gotoInProgressValue)

        positionAltitudeAzimuth = self._handController.positionAltitudeAzimuth
        if positionAltitudeAzimuth is None:
            positionAltitudeAzimuth  = "n/a"
        else:
            positionAltitudeAzimuth  = "altitude {:.6f}° ; azimuth = {:.6f}°".format(positionAltitudeAzimuth[0], positionAltitudeAzimuth[1])

        self._positionAltitudeAzimuthValue.setText(positionAltitudeAzimuth)

        positionRightAscensionDeclination = self._handController.positionRightAscensionDeclination
        if positionRightAscensionDeclination is None:
            positionRightAscensionDeclinationValue  = "n/a"
        else:
            positionRightAscensionDeclinationValue  = "right ascension {:.6f}° ; declination = {:.6f}°".format(positionRightAscensionDeclination[0], positionRightAscensionDeclination[1])

        self._positionRightAscensionDeclinationValue.setText(positionRightAscensionDeclinationValue)

    @QtSlot()
    def _connectionButtonClicked(self):

        connectionStatus = self._handController.connectionStatus

        #print("==>", connectionStatus)

        if connectionStatus == NexstarHandControllerConnectionStatus.DISCONNECTED:
            self._handController.openConnection()
        elif connectionStatus == NexstarHandControllerConnectionStatus.CONNECTED:
            self._handController.closeConnection()

    @QtSlot()
    def _slewLeftButtonClicked(self):
        self._handController.slew_variable(NexstarDeviceId.AZM_RA_MOTOR, -3.0)

    @QtSlot()
    def _slewRightButtonClicked(self):
        self._handController.slew_variable(NexstarDeviceId.AZM_RA_MOTOR, +3.0)

    @QtSlot()
    def _slewUpButtonClicked(self):
        self._handController.slew_variable(NexstarDeviceId.ALT_DEC_MOTOR, +3.0)

    @QtSlot()
    def _slewDownButtonClicked(self):
        self._handController.slew_variable(NexstarDeviceId.ALT_DEC_MOTOR, -3.0)

    @QtSlot()
    def _slewStopButtonClicked(self):
        self._handController.slew_variable(NexstarDeviceId.AZM_RA_MOTOR,  0.0)
        self._handController.slew_variable(NexstarDeviceId.ALT_DEC_MOTOR, 0.0)

class CameraWidget(QtGui.QWidget):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        handController = NexstarHandControllerQt()

        layout = QtGui.QVBoxLayout()

        imageLabel = QtGui.QLabel()

        self.setLayout(layout)

        self._imageLabel = imageLabel

        self._updateTimer = QtCore.QTimer()
        self._updateTimer.timeout.connect(self._refreshImage)
        self._updateTimer.start(1000)

    @QtSlot()
    def _refreshImage(self):
        self._imageLabel.setText("HALLO")

        cmd_1 = "gphoto2 --set-config /main/capturesettings/shutterspeed2=1/100 --force-overwrite --capture-image-and-download"
        cmd_2 = "dcraw -6 -T capt0000.nef"

        print("refresh")
        #subprocess.call(cmd_1.split())

class CentralWidget(QtGui.QWidget):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        layout = QtGui.QVBoxLayout()
        nexstarWidget = NexstarWidget()
        layout.addWidget(nexstarWidget)
        cameraWidget = CameraWidget()
        layout.addWidget(cameraWidget)
        self.setLayout(layout)

class MainWindow(QtGui.QMainWindow):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        centralWidget = CentralWidget()
        self.setCentralWidget(centralWidget)

class Application(QtGui.QApplication):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._mainWindow = MainWindow()
        self._mainWindow.show()

def main():
    app = Application(sys.argv)
    exitcode = QtGui.QApplication.exec_()
    return exitcode

if __name__ == "__main__":
    exitcode = main()
    sys.exit(exitcode)