コード例 #1
0
class Weather(QtCore.QThread):
    logger = logging.getLogger(__name__)  # get logger for  problems
    signalWeatherData = QtCore.pyqtSignal(
        [dict], name='weatherData')  # single for data transfer to gui
    signalWeatherConnected = QtCore.pyqtSignal(
        [int], name='weatherConnected')  # signal for connection status

    def __init__(self, app):
        super().__init__()
        self.app = app
        self.connected = 2
        self.ascom = None  # placeholder for ascom driver object
        self.chooser = None  # placeholder for ascom chooser object
        self.driverName = ''  # driver object name
        self.slewing = False
        self.counter = 0

    def run(self):  # runnable for doing the work
        pythoncom.CoInitialize()  # needed for doing CO objects in threads
        self.connected = 0  # set connection flag for stick itself
        self.counter = 0
        while True:  # main loop for stick thread
            self.signalWeatherConnected.emit(
                self.connected)  # send status to GUI
            if self.connected == 1:  # differentiate between dome connected or not
                if self.counter == 0:  # jobs once done at the beginning
                    self.getStatusOnce()  # task once
                if self.counter % 2 == 0:  # all tasks with 200 ms
                    self.getStatusFast()  # polling the mount status Ginfo
                if self.counter % 20 == 0:  # all tasks with 3 s
                    self.getStatusMedium()  # polling the mount
                if self.counter % 300 == 0:  # all task with 1 minute
                    self.getStatusSlow()  # slow ones
                self.counter += 1  # increasing counter for selection
                time.sleep(.1)
            else:
                try:
                    if self.driverName == '':
                        self.connected = 2
                    else:
                        self.ascom = Dispatch(self.driverName)  # load driver
                        self.ascom.connected = True
                        self.connected = 1  # set status to connected
                        self.logger.debug(
                            'run            -> driver chosen:{0}'.format(
                                self.driverName))
                except Exception as e:  # if general exception
                    if self.driverName != '':
                        self.logger.error(
                            'run Weather    -> general exception: {0}'.format(
                                e))  # write to logger
                    if self.driverName == '':
                        self.connected = 2
                    else:
                        self.connected = 0  # run the driver setup dialog
                finally:  # still continua and try it again
                    pass  # needed for continue
                time.sleep(1)  # wait for the next cycle
        self.ascom.Quit()
        pythoncom.CoUninitialize()  # needed for doing COm objects in threads
        self.terminate()  # closing the thread at the end

    def __del__(self):  # remove thread
        self.wait()

    def getStatusFast(self):
        pass

    def getStatusMedium(self):
        data = dict()
        try:
            data['DewPoint'] = self.ascom.DewPoint
            data['Temperature'] = self.ascom.Temperature
            data['Humidity'] = self.ascom.Humidity
            data['Pressure'] = self.ascom.Pressure
            data['CloudCover'] = self.ascom.CloudCover
            data['RainRate'] = self.ascom.RainRate
            data['WindSpeed'] = self.ascom.WindSpeed
            data['WindDirection'] = self.ascom.WindDirection
            self.signalWeatherData.emit(data)  # send data
        except Exception as e:
            self.logger.error(
                'getStatusMedium-> error accessing weather ascom data: {}'.
                format(e))

    def getStatusSlow(self):
        pass

    def getStatusOnce(self):
        pass

    def setupDriver(self):  #
        try:
            self.chooser = Dispatch('ASCOM.Utilities.Chooser')
            self.chooser.DeviceType = 'ObservingConditions'
            self.driverName = self.chooser.Choose(self.driverName)
            self.logger.debug('setupDriverWeat-> driver chosen:{0}'.format(
                self.driverName))
            if self.driverName == '':
                self.connected = 2
            else:
                self.connected = 0  # run the driver setup dialog
        except Exception as e:  # general exception
            self.app.messageQueue.put(
                'Driver Exception in setupWeather')  # write to gui
            self.logger.error(
                'setupWeather    -> general exception:{0}'.format(
                    e))  # write to log
            if self.driverName == '':
                self.connected = 2
            else:
                self.connected = 0  # run the driver setup dialog
        finally:  # continue to work
            pass  # python necessary
コード例 #2
0
class Dome(QtCore.QThread):
    # signals for communication to main Thread / GUI
    logger = logging.getLogger(__name__)
    signalDomeConnected = QtCore.pyqtSignal([int], name='domeConnected')
    signalDomPointer = QtCore.pyqtSignal([float], name='domePointer')

    def __init__(self, app):
        super().__init__()
        self.app = app
        self.connected = 2
        self.ascom = None  # placeholder for ascom driver object
        self.chooser = None  # placeholder for ascom chooser object
        self.driverName = ''  # driver object name
        self.slewing = False
        self.counter = 0

    def run(self):  # runnable for doing the work
        pythoncom.CoInitialize()  # needed for doing CO objects in threads
        self.connected = 0  # set connection flag for stick itself
        self.counter = 0
        while True:  # main loop for stick thread
            self.signalDomeConnected.emit(self.connected)  # send status to GUI
            if self.connected == 1:  # differentiate between dome connected or not
                if self.counter == 0:  # jobs once done at the beginning
                    self.getStatusOnce()  # task once
                if self.counter % 2 == 0:  # all tasks with 200 ms
                    self.getStatusFast()  # polling the mount status Ginfo
                if self.counter % 20 == 0:  # all tasks with 3 s
                    self.getStatusMedium()  # polling the mount
                if self.counter % 300 == 0:  # all task with 1 minute
                    self.getStatusSlow()  # slow ones
                self.counter += 1  # increasing counter for selection
                time.sleep(.1)
            else:
                try:
                    if self.driverName == '':
                        self.connected = 2
                    else:
                        self.ascom = Dispatch(self.driverName)  # load driver
                        self.ascom.connected = True
                        self.connected = 1  # set status to connected
                        self.logger.debug(
                            'run            -> driver chosen:{0}'.format(
                                self.driverName))
                except Exception as e:  # if general exception
                    if self.driverName != '':
                        self.logger.error(
                            'run Dome       -> general exception: {0}'.format(
                                e))  # write to logger
                    if self.driverName == '':
                        self.connected = 2
                    else:
                        self.connected = 0  # run the driver setup dialog
                finally:  # still continua and try it again
                    pass  # needed for continue
                time.sleep(1)  # wait for the next cycle
        self.ascom.Quit()
        pythoncom.CoUninitialize()  # needed for doing COm objects in threads
        self.terminate()  # closing the thread at the end

    def __del__(self):  # remove thread
        self.wait()  #

    def getStatusFast(self):
        self.slewing = self.ascom.Slewing
        self.signalDomPointer.emit(self.ascom.Azimuth)

    def getStatusMedium(self):
        pass

    def getStatusSlow(self):
        pass

    def getStatusOnce(self):
        pass

    def setupDriver(self):  #
        try:
            self.chooser = Dispatch('ASCOM.Utilities.Chooser')
            self.chooser.DeviceType = 'Dome'
            self.driverName = self.chooser.Choose(self.driverName)
            self.logger.debug('setupDriverDome -> driver chosen:{0}'.format(
                self.driverName))
            if self.driverName == '':
                self.connected = 2
            else:
                self.connected = 0  # run the driver setup dialog
        except Exception as e:  # general exception
            self.app.messageQueue.put(
                'Driver Exception in setupDome')  # write to gui
            self.logger.error(
                'setupDriverDome -> general exception:{0}'.format(
                    e))  # write to log
            if self.driverName == '':
                self.connected = 2
            else:
                self.connected = 0  # run the driver setup dialog
        finally:  # continue to work
            pass  # python necessary
コード例 #3
0
class Mount(QtCore.QThread):
    logger = logging.getLogger(__name__)  # enable logging
    signalMountConnected = QtCore.pyqtSignal(
        [bool], name='mountConnected')  # signal for connection status
    signalMountAzAltPointer = QtCore.pyqtSignal([float, float],
                                                name='mountAzAltPointer')
    signalMountTrackPreview = QtCore.pyqtSignal(name='mountTrackPreview')

    BLUE = 'background-color: rgb(42, 130, 218)'
    DEFAULT = 'background-color: rgb(32,32,32); color: rgb(192,192,192)'

    def __init__(self, app):
        super().__init__()  # init of the class parent with super
        self.app = app  # accessing ui object from mount class

        self.statusReference = {
            '0': 'Tracking',
            '1': 'Stopped after STOP',
            '2': 'Slewing to park position',
            '3': 'Unparking',
            '4': 'Slewing to home position',
            '5': 'Parked',
            '6': 'Slewing or going to stop',
            '7': 'Tracking Off no move',
            '8': 'Motor low temperature',
            '9': 'Tracking outside limits',
            '10': 'Following Satellite',
            '11': 'User OK Needed',
            '98': 'Unknown Status',
            '99': 'Error'
        }  # conversion list Gstat to text
        self.ra = 0  # mount reported ra to J2000 converted
        self.dec = 0  # mount reported dec to J2000 converted
        self.raJnow = 0
        self.decJnow = 0
        self.az = 0  # mount reported azimuth
        self.alt = 0  # mount reported altitude
        self.stat = 0  # mount status (from Gstat command)
        self.slewing = False  # from *D' command
        self.site_lat = 49  # site lat
        self.site_lon = 0  # site lon
        self.site_height = 0  # site height
        self.jd = 2451544.5  # julian date
        self.sidereal_time = ''  # local sidereal time
        self.pierside = 0  # side of pier (E/W)
        self.timeToFlip = '200'  # minutes to flip
        self.refractionTemp = '20.0'  # coordinate transformation need temp
        self.refractionPressure = '900.0'  # and pressure
        self.transform = None  # ascom novas library entry point
        self.ascom = None  # ascom mount driver entry point
        self.mountAlignRMSsum = 0  # variable for counting RMS over stars
        self.mountAlignmentPoints = []  # alignment point for modeling
        self.mountAlignNumberStars = 0  # number of stars
        self.counter = 0  # counter im main loop
        self.connected = False  # connection status
        self.transformConnected = False
        self.driverName = 'ASCOM.FrejvallGM.Telescope'  # default driver name is Per's driver
        self.chooser = None  # object space
        self.driver_real = False  # identifier, if data is real (or simulation
        self.value_azimuth = 0.0  # object for Sz command
        self.value_altitude = 0.0  # object for Sa command
        self.transformationLock = threading.Lock(
        )  # locking object for single access to ascom transformation object
        self.sendCommandLock = threading.Lock()

    def run(self):  # runnable of the thread
        pythoncom.CoInitialize()  # needed for doing COM objects in threads
        try:  # start accessing a com object
            self.transform = Dispatch(
                'ASCOM.Astrometry.Transform.Transform'
            )  # novas library for Jnow J2000 conversion through ASCOM
            self.transformConnected = True
        except Exception as e:  # exception handling
            self.app.messageQueue.put(
                'Error loading ASCOM transform Driver')  # write to gui
            self.logger.error(
                'run Mount      -> loading ASCOM transform error:{0}'.format(
                    e))  # write logfile
        finally:  # we don't stop on error the wizzard
            pass  # python specific
        self.connected = False  # init of connection status
        self.counter = 0  # init count for managing different cycle times
        while True:  # main loop in thread
            self.signalMountConnected.emit(
                self.connected)  # sending the connection status
            if self.connected:  # when connected, starting the work
                if not self.app.commandQueue.empty(
                ):  # checking if in queue is something to do
                    command = self.app.commandQueue.get(
                    )  # if yes, getting the work command
                    if command == 'GetAlignmentModel':  # checking which command was sent
                        self.app.ui.btn_getActualModel.setStyleSheet(self.BLUE)
                        self.getAlignmentModel(
                        )  # running the appropriate method
                        self.app.ui.btn_getActualModel.setStyleSheet(
                            self.DEFAULT)
                    elif command == 'ClearAlign':
                        self.sendCommand('delalig')
                    elif command == 'RunTargetRMSAlignment':
                        self.app.ui.btn_runTargetRMSAlignment.setStyleSheet(
                            self.BLUE)
                        self.runTargetRMSAlignment()
                        self.app.ui.btn_runTargetRMSAlignment.setStyleSheet(
                            self.DEFAULT)
                    elif command == 'DeleteWorstPoint':
                        self.app.ui.btn_deleteWorstPoint.setStyleSheet(
                            self.BLUE)
                        self.deleteWorstPoint()
                        self.app.ui.btn_deleteWorstPoint.setStyleSheet(
                            self.DEFAULT)
                    elif command == 'BackupModel':
                        self.app.ui.btn_backupModel.setStyleSheet(
                            self.BLUE)  # button blue
                        self.backupModel()
                        self.app.ui.btn_backupModel.setStyleSheet(
                            self.DEFAULT)  # button to default back
                    elif command == 'RestoreModel':
                        self.app.ui.btn_restoreModel.setStyleSheet(self.BLUE)
                        self.restoreModel()
                        self.app.ui.btn_restoreModel.setStyleSheet(
                            self.DEFAULT)
                    elif command == 'LoadSimpleModel':
                        self.app.ui.btn_loadSimpleModel.setStyleSheet(
                            self.BLUE)
                        self.loadSimpleModel()
                        self.app.ui.btn_loadSimpleModel.setStyleSheet(
                            self.DEFAULT)
                    elif command == 'SaveSimpleModel':
                        self.app.ui.btn_saveSimpleModel.setStyleSheet(
                            self.BLUE)
                        self.saveSimpleModel()
                        self.app.ui.btn_saveSimpleModel.setStyleSheet(
                            self.DEFAULT)
                    elif command == 'SetRefractionParameter':
                        self.setRefractionParameter()
                    elif command == 'FLIP':
                        self.flipMount()
                    else:
                        self.sendCommand(
                            command
                        )  # doing the command directly to mount (no method necessary)
                    self.app.commandQueue.task_done()
                else:  # if not connected, the we should do this
                    if self.counter == 0:  # jobs once done at the beginning
                        self.getStatusOnce()  # task once
                    if self.counter % 2 == 0:  # all tasks with 400 ms
                        self.getStatusFast()  # polling the mount status Ginfo
                    if self.counter % 15 == 0:  # all tasks with 3 s
                        self.getStatusMedium()  # polling the mount
                    if self.counter % 150 == 0:  # all task with 30 seconds
                        self.getStatusSlow()  # slow ones
                time.sleep(0.2)  # time base is 200 ms
                self.counter += 1  # increasing counter for selection
            else:  # when not connected try to connect
                try:
                    self.ascom = Dispatch(
                        self.driverName)  # select win32 driver
                    if self.driverName == 'ASCOM.FrejvallGM.Telescope':  # identify real telescope against simulator
                        self.driver_real = True  # set it
                    else:
                        self.driver_real = False  # set it
                    self.ascom.connected = True  # connect to mount
                    self.connected = True  # setting connection status from driver
                    self.counter = 0  # whenever reconnect, then start from scratch
                except Exception as e:  # error handling
                    if self.driverName != '':  # if driver is not empty, than error messages
                        self.logger.error(
                            'run Mount      -> Driver COM Error in dispatchMount: {0}'
                            .format(e))  # to logger
                    self.connected = False  # connection broken
                finally:  # we don't stop, but try it again
                    time.sleep(1)  # try it every second, not more
        self.ascom.Quit()  # close ascom mount object
        self.transform.Quit()  # close ascom novas transform object
        pythoncom.CoUninitialize()  # needed for doing COM objects in threads
        self.terminate()  # closing the thread at the end

    def __del__(self):  # remove thread
        self.wait()  # wait for stop of thread

    def sendCommand(self,
                    command):  # core routine for sending commands to mount
        reply = ''  # reply is empty
        self.sendCommandLock.acquire()
        if self.driver_real:
            try:  # all with error handling
                if command in [
                        'AP', 'hP', 'PO', 'RT0', 'RT1', 'RT2', 'RT9', 'STOP',
                        'U2'
                ]:  # these are the commands, which do not expect a return value
                    self.ascom.CommandBlind(command)  # than do blind command
                else:  #
                    reply = self.ascom.CommandString(
                        command)  # with return value do regular command
            except pythoncom.com_error as e:  # error handling
                self.app.messageQueue.put(
                    'Driver COM Error in sendCommand')  # gui
                self.logger.error(
                    'sendCommand Mount -> error: {0} command:{1}  reply:{2} '.
                    format(e, command, reply))  # logger
                self.connected = False  # in case of error, the connection might be broken
            finally:  # we don't stop
                if len(reply) > 0:  # if there is a reply
                    value = reply.rstrip('#').strip()  # return the value
                    if command == 'CMS':
                        self.logger.debug(
                            'sendCommand    -> Return Value Add Model Point: {0}'
                            .format(reply))
                else:  #
                    value = ''  # nothing
            self.sendCommandLock.release()
            return value
        else:  # from here we doing the simulation for 10micron mounts commands
            value = ''
            if command == 'Gev':  # which are special, but only for the most important for MW to run
                value = str(self.ascom.SiteElevation)
            elif command == 'Gmte':
                value = '0125'
            elif command == 'Gt':
                value = self.decimalToDegree(self.ascom.SiteLatitude, True,
                                             False)
            elif command == 'Gg':
                lon = self.decimalToDegree(self.ascom.SiteLongitude, True,
                                           False)
                if lon[0] == '-':  # due to compatibility to LX200 protocol east is negative
                    lon1 = lon.replace('-', '+')  # change that
                else:
                    lon1 = lon.replace('+', '-')  # and vice versa
                value = lon1
            elif command.startswith('Sz'):
                self.value_azimuth = float(
                    command[2:5]) + float(command[6:8]) / 60
            elif command.startswith('Sa'):
                self.value_altitude = float(
                    command[2:5]) + float(command[6:8]) / 60
            elif command == 'MS':
                self.ascom.Tracking = False
                self.ascom.SlewToAltAzAsync(self.value_azimuth,
                                            self.value_altitude)
                self.ascom.Tracking = True
            elif command == 'MA':
                self.ascom.Tracking = False
                self.ascom.SlewToAltAzAsync(self.value_azimuth,
                                            self.value_altitude)
                self.ascom.Tracking = False
            elif command == 'GS':
                value = self.decimalToDegree(self.ascom.SiderealTime, False,
                                             False)
            elif command == 'GRTMP':
                value = '10.0'
            elif command == 'Ginfo':
                self.raJnow = self.ascom.RightAscension
                self.decJnow = self.ascom.Declination
                az = self.ascom.Azimuth
                alt = self.ascom.Altitude
                if self.ascom.Slewing:
                    stat = 6
                else:
                    if self.ascom.Tracking:
                        stat = 0
                    else:
                        stat = 7
                jd = self.ascom.SiderealTime + 2440587.5
                if self.ascom.SideOfPier == 0:
                    pierside = 'E'
                else:
                    pierside = 'W'
                if self.ascom.Slewing:
                    slew = 1
                else:
                    slew = 0
                value = '{0},{1},{2},{3},{4},{5},{6},{7}#'.format(
                    self.raJnow, self.decJnow, pierside, az, alt, jd, stat,
                    slew)
            elif command == 'PO':
                self.ascom.Unpark()
            elif command == 'hP':
                self.ascom.Park()
            elif command == 'AP':
                self.ascom.Tracking = True
            elif command == 'RT9':
                self.ascom.Tracking = False
            elif command == 'GTMP1':
                value = '10.0'
            elif command == 'GRPRS':
                value = '990.0'
            elif command == 'Guaf':
                value = '0'
            elif command == 'GMs':
                value = '15'
            elif command == 'Gh':
                value = '90'
            elif command == 'Go':
                value = '00'
            elif command == 'Gdat':
                value = '0'
            elif command in ['GVD', 'GVN', 'GVP', 'GVT', 'GVZ']:
                value = 'Simulation'
            elif command == 'GREF':
                value = '1'
            elif command == 'CMS':
                value = 'V'
            elif command == 'getalst':
                value = '0'
            else:
                pass
        self.sendCommandLock.release()
        return value

    def transformNovas(
            self,
            ra,
            dec,
            transform=1):  # wrapper for the novas ascom implementation
        self.transformationLock.acquire(
        )  # which is not threat safe, so we have to do this
        self.transform.SiteTemperature = float(
            self.refractionTemp)  # needs refraction temp
        if transform == 1:  # 1 = J2000 -> alt/az
            if ra < 0:  # ra has to be between 0 and 23,99999
                ra += 24  #
            if ra >= 24:  # so set it right
                ra -= 24
            self.transform.SetJ2000(ra, dec)  # set J2000 ra, dec
            val1 = self.transform.AzimuthTopocentric  # convert az
            val2 = self.transform.ElevationTopocentric  # convert alt
        elif transform == 2:  # 2 = Jnow -> J2000
            self.transform.SetTopocentric(ra, dec)  # set Jnow data
            val1 = self.transform.RAJ2000
            val2 = self.transform.DECJ2000
        elif transform == 3:  # 3 = J2000 -> JNow
            self.transform.SetJ2000(ra, dec)  # set J2000 data
            val1 = self.transform.RATopocentric
            val2 = self.transform.DECTopocentric
        elif transform == 4:  # 1 = JNow -> alt/az
            if ra < 0:  # ra has to be between 0 and 23,99999
                ra += 24  #
            if ra >= 24:  # so set it right
                ra -= 24
            self.transform.SetTopocentric(ra, dec)  # set JNow ra, dec
            val1 = self.transform.AzimuthTopocentric  # convert az
            val2 = self.transform.ElevationTopocentric  # convert alt
        else:
            val1 = ra
            val2 = dec
        self.transformationLock.release()  # release locking for thread safety
        return val1, val2

    def flipMount(self):  # doing the flip of the mount
        reply = self.sendCommand('FLIP').rstrip('#').strip()
        if reply == '0':  # error handling if not successful
            self.app.messageQueue.put(
                'Flip Mount could not be executed !')  # write to gui
            self.logger.debug('flipMount      -> error: {0}'.format(
                reply))  # write to logger

    def ra_dec_lst_to_az_alt(self, ra, dec, lst):
        LAT = self.site_lat
        HA = (lst - ra) * 15
        if HA >= 360:
            HA -= 360
        elif HA <= 0:
            HA += 360
        alt = math.asin(
            math.sin(dec) * math.sin(LAT) +
            math.cos(dec) * math.cos(LAT) * math.cos(HA))
        A = math.acos((math.sin(dec) - math.sin(alt) * math.sin(LAT)) /
                      (math.cos(alt) * math.cos(LAT)))
        if math.sin(HA) < 0:
            az = 360 - A
        else:
            az = A
        return az, alt

    def degStringToDecimal(
        self,
        value,
        splitter=':'
    ):  # conversion between Strings formats and decimal representation
        sign = 1
        if '-' in value:
            value = value.replace('-', '')
            sign = -1
        elif '+' in value:
            value = value.replace('+', '')
        try:
            if len(value.split(splitter)) == 3:
                hour, minute, second = value.split(splitter)
                return (float(hour) + float(minute) / 60 +
                        float(second) / 3600) * sign
            elif len(value.split(splitter)) == 2:
                hour, minute = value.split(splitter)
                return (float(hour) + float(minute) / 60) * sign
        except Exception as e:
            self.logger.error(
                'degStringToDeci-> error in conversion of:{0} with splitter:{1}, e:{2}'
                .format(value, splitter, e))
            return 0

    @staticmethod
    def decimalToDegree(
            value,
            with_sign,
            with_decimal,
            spl=':'):  # format decimal value to string in degree format
        if value >= 0:
            sign = '+'
        else:
            sign = '-'
        value = abs(value)
        hour = int(value)
        minute = int((value - hour) * 60)
        second = int(((value - hour) * 60 - minute) * 60)
        if with_decimal:
            second_dec = '.{0:1d}'.format(
                int((((value - hour) * 60 - minute) * 60 - second) * 10))
        else:
            second_dec = ''
        if with_sign:
            return '{0}{1:02d}{5}{2:02d}{5}{3:02d}{4}'.format(
                sign, hour, minute, second, second_dec, spl)
        else:
            return '{0:02d}{4}{1:02d}{4}{2:02d}{3}'.format(
                hour, minute, second, second_dec, spl)

    def getAlignmentModel(self):  # download alignment model from mount
        self.app.mountDataQueue.put({
            'Name': 'ModelStarError',
            'Value': 'delete'
        })  # clear the window in gui
        self.mountAlignRMSsum = 0  # set RMS sum to 0 for calculation
        self.mountAlignmentPoints = []  # clear the alignment points downloaded
        self.mountAlignNumberStars = int(
            self.sendCommand('getalst').rstrip(
                '#').strip())  # get number of stars
        if self.mountAlignNumberStars == 0:  # if no stars, finish
            return False
        for i in range(1, self.mountAlignNumberStars +
                       1):  # otherwise download them step for step
            try:
                reply = self.sendCommand('getalp{0:d}'.format(i)).split(',')
            except pythoncom.com_error as e:
                self.app.messageQueue.put(
                    'Driver COM Error in sendCommand {0}'.format(e))
                return False
            ha = reply[0].strip().split('.')[0]
            dec = reply[1].strip().split('.')[0]
            errorRMS = float(reply[2].strip())
            errorAngle = reply[3].strip().rstrip('#')
            self.mountAlignRMSsum += errorRMS**2
            self.mountAlignmentPoints.append((i, errorRMS))
            dec = dec.replace('*', ':')
            self.app.mountDataQueue.put({
                'Name':
                'ModelStarError',
                'Value':
                '#{0:02d} HA: {1} DEC: {2} Err: {3:4.1f}\x22 EA: {4:3s}\xb0\n'.
                format(i, ha, dec, errorRMS, errorAngle)
            })
        self.app.mountDataQueue.put({
            'Name': 'NumberAlignmentStars',
            'Value': self.mountAlignNumberStars
        })  # write them to gui
        self.app.mountDataQueue.put({
            'Name':
            'ModelRMSError',
            'Value':
            '{0:3.1f}'.format(
                math.sqrt(self.mountAlignRMSsum / self.mountAlignNumberStars))
        })  # set the error values in gui
        return True

    def runTargetRMSAlignment(self):
        if not self.getAlignmentModel():
            return
        self.mountAlignRMSsum = 999.9  # set maximum
        self.mountAlignNumberStars = 4  # set minimum for stars
        while math.sqrt(self.mountAlignRMSsum / self.mountAlignNumberStars) > float(self.app.ui.targetRMS.value()) \
                and self.mountAlignNumberStars > 3:
            a = sorted(self.mountAlignmentPoints,
                       key=itemgetter(1),
                       reverse=True)  # index 0 ist the worst star
            try:  # delete the worst star
                self.sendCommand('delalst{0:d}'.format(a[0][0]))
            except pythoncom.com_error as e:
                self.app.messageQueue.put(
                    'Driver COM Error in sendCommand {0}'.format(e))
            self.getAlignmentModel()

    def deleteWorstPoint(self):
        if not self.getAlignmentModel():
            return
        self.mountAlignRMSsum = 999.9  # set maximum
        self.mountAlignNumberStars = 4  # set minimum for stars
        if self.mountAlignNumberStars > 3:
            a = sorted(self.mountAlignmentPoints,
                       key=itemgetter(1),
                       reverse=True)  # index 0 ist the worst star
            try:  # delete the worst star
                self.sendCommand('delalst{0:d}'.format(a[0][0]))
            except pythoncom.com_error as e:
                self.app.messageQueue.put(
                    'Driver COM Error in sendCommand {0}'.format(e))
            self.getAlignmentModel()

    def saveActualModel(self, target):
        self.sendCommand('modeldel0' + target)
        reply = self.sendCommand('modelsv0' + target)
        if reply == '1':
            return True
        else:
            return False

    def loadActualModel(self, target):
        reply = self.sendCommand('modelld0' + target)
        if reply == '1':
            return True
        else:
            return False

    def backupModel(self):
        if self.saveActualModel('BACKUP'):
            self.app.messageQueue.put('Actual Model save to BACKUP')
        else:
            self.logger.debug(
                'backupModel    -> Model BACKUP could not be saved')  # log it

    def restoreModel(self):
        if self.loadActualModel('BACKUP'):
            self.app.messageQueue.put('Actual Model loaded from BACKUP')
        else:
            self.app.messageQueue.put(
                'There is no model named BACKUP or error while loading')
            self.logger.debug(
                'backupModel    -> Model BACKUP could not be loaded')  # log it

    def saveSimpleModel(self):
        if self.saveActualModel('SIMPLE'):
            self.app.messageQueue.put('Actual Model save to SIMPLE')
        else:
            self.logger.debug(
                'saveSimpleModel-> Model SIMPLE could not be saved')  # log it

    def loadSimpleModel(self):
        if self.loadActualModel('SIMPLE'):
            self.app.messageQueue.put('Actual Model loaded from SIMPLE')
        else:
            self.app.messageQueue.put(
                'There is no model named SIMPLE or error while loading')
            self.logger.debug(
                'loadSimpleModel-> Model SIMPLE could not be loaded')  # log it

    def setRefractionParameter(self):
        if self.app.ui.le_pressureStick.text() != '':  # value must be there
            self.sendCommand('SRPRS{0:04.1f}'.format(
                float(self.app.ui.le_pressureStick.text())))
            if float(self.app.ui.le_temperatureStick.text()) > 0:
                self.sendCommand('SRTMP+{0:03.1f}'.format(
                    float(self.app.ui.le_temperatureStick.text())))
            else:
                self.sendCommand('SRTMP-{0:3.1f}'.format(
                    -float(self.app.ui.le_temperatureStick.text())))
            self.app.mountDataQueue.put({
                'Name': 'GetRefractionTemperature',
                'Value': self.sendCommand('GRTMP')
            })
            self.app.mountDataQueue.put({
                'Name': 'GetRefractionPressure',
                'Value': self.sendCommand('GRPRS')
            })

    def getStatusFast(self):  # fast status item like pointing
        reply = self.sendCommand('GS')
        if reply:
            self.sidereal_time = reply.strip('#')
            self.app.mountDataQueue.put({
                'Name':
                'GetLocalTime',
                'Value':
                '{0}'.format(self.sidereal_time)
            })  # Sidereal local time
        reply = self.sendCommand('GR')
        if reply:
            self.raJnow = self.degStringToDecimal(reply)
        reply = self.sendCommand('GD')
        if reply:
            self.decJnow = self.degStringToDecimal(reply)
        reply = self.sendCommand(
            'Ginfo')  # use command "Ginfo" for fast topics
        if reply:  # if reply is there
            ra, dec, self.pierside, az, alt, self.jd, stat, slew = reply.rstrip(
                '#').strip().split(',')  # split the response to its parts
            # self.raJnow = float(ra)
            # self.decJnow = float(dec)
            self.jd = self.jd.rstrip('#')  # needed for 2.14.8 beta firmware
            self.az = float(az)  # same to azimuth
            self.alt = float(alt)  # and altitude
            self.stat = int(stat)  # status should be int for referencing list
            self.slewing = (slew == '1')  # set status slewing
            self.ra, self.dec = self.transformNovas(self.raJnow, self.decJnow,
                                                    2)  # convert J2000
            ra_show = self.decimalToDegree(self.ra, False, False)
            dec_show = self.decimalToDegree(self.dec, True, False)
            self.app.mountDataQueue.put({
                'Name': 'GetTelescopeDEC',
                'Value': '{0}'.format(dec_show)
            })  # put dec to gui
            self.app.mountDataQueue.put({
                'Name': 'GetTelescopeRA',
                'Value': '{0}'.format(ra_show)
            })  # put ra to gui
            self.app.mountDataQueue.put({
                'Name': 'GetTelescopeAltitude',
                'Value': '{0:03.2f}'.format(self.alt)
            })  # Altitude
            self.app.mountDataQueue.put({
                'Name': 'GetTelescopeAzimuth',
                'Value': '{0:03.2f}'.format(self.az)
            })  # Azimuth
            self.app.mountDataQueue.put({
                'Name': 'GetMountStatus',
                'Value': '{0}'.format(self.stat)
            })  # Mount status -> slew to stop
            if str(self.pierside) == str('W'):  # pier side
                self.app.mountDataQueue.put({
                    'Name': 'GetTelescopePierSide',
                    'Value': 'WEST'
                })  # Transfer to test in GUI
            else:  #
                self.app.mountDataQueue.put({
                    'Name': 'GetTelescopePierSide',
                    'Value': 'EAST'
                })  # Transfer to Text for GUI
            self.signalMountAzAltPointer.emit(
                self.az,
                self.alt)  # set azalt Pointer in diagrams to actual pos
            self.timeToFlip = self.sendCommand('Gmte')
            self.app.mountDataQueue.put({
                'Name': 'GetTimeToTrackingLimit',
                'Value': self.timeToFlip
            })  # Flip time
            # TODO:  precision of moutn jnow data # print(self.raJnow - float(ra), self.decJnow - float(dec))

    def getStatusMedium(self):  # medium status items like refraction
        if self.app.ui.checkAutoRefraction.isChecked(
        ):  # check if autorefraction is set
            if self.stat != 0:  # if no tracking, than autorefraction is good
                self.setRefractionParameter(
                )  # transfer refraction from to mount
            else:  #
                success, message = self.app.cpObject.SgGetDeviceStatus(
                    'Camera')  # getting the Camera status
                if success and message in [
                        'IDLE', 'DOWNLOADING'
                ]:  # if tracking, when camera is idle or downloading
                    self.setRefractionParameter(
                    )  # transfer refraction to mount
                else:  # otherwise
                    self.logger.debug(
                        'getStatusMedium-> no autorefraction: {0}'.format(
                            message))  # no autorefraction is possible
        self.signalMountTrackPreview.emit()

    def getStatusSlow(self):  # slow update item like temps
        self.timeToFlip = self.sendCommand('Gmte')
        self.app.mountDataQueue.put({
            'Name': 'GetTimeToTrackingLimit',
            'Value': self.timeToFlip
        })  # Flip time
        self.refractionTemp = self.sendCommand('GRTMP')
        self.app.mountDataQueue.put({
            'Name': 'GetRefractionTemperature',
            'Value': self.refractionTemp
        })  # refraction temp out of mount
        self.refractionPressure = self.sendCommand('GRPRS')
        self.app.mountDataQueue.put({
            'Name': 'GetRefractionPressure',
            'Value': self.refractionPressure
        })  # refraction pressure out of mount
        self.app.mountDataQueue.put({
            'Name': 'GetTelescopeTempDEC',
            'Value': self.sendCommand('GTMP1')
        })  # temp motor circuit of both axes
        self.app.mountDataQueue.put({
            'Name': 'GetSlewRate',
            'Value': self.sendCommand('GMs')
        })  # get actual slew rate
        self.app.mountDataQueue.put({
            'Name': 'GetRefractionStatus',
            'Value': self.sendCommand('GREF')
        })
        self.app.mountDataQueue.put({
            'Name': 'GetUnattendedFlip',
            'Value': self.sendCommand('Guaf')
        })
        self.app.mountDataQueue.put({
            'Name': 'GetDualAxisTracking',
            'Value': self.sendCommand('Gdat')
        })
        self.app.mountDataQueue.put({
            'Name': 'GetCurrentHorizonLimitHigh',
            'Value': self.sendCommand('Gh')
        })
        self.app.mountDataQueue.put({
            'Name': 'GetCurrentHorizonLimitLow',
            'Value': self.sendCommand('Go')
        })

    def getStatusOnce(self):  # one time updates for settings
        self.sendCommand('U2')  # Set high precision mode
        self.site_height = self.sendCommand('Gev')  # site height
        lon1 = self.sendCommand('Gg')  # get site lon
        if lon1[0] == '-':  # due to compatibility to LX200 protocol east is negative
            self.site_lon = lon1.replace('-', '+')  # change that
        else:
            self.site_lon = lon1.replace('+', '-')  # and vice versa
        self.site_lat = self.sendCommand('Gt')  # get site latitude
        self.transform.Refraction = False  # set parameter for ascom nova library
        self.transform.SiteElevation = float(self.site_height)  # height
        self.transform.SiteLatitude = self.degStringToDecimal(
            self.site_lat)  # site lat
        self.transform.SiteLongitude = self.degStringToDecimal(
            self.site_lon)  # site lon
        self.app.mountDataQueue.put({
            'Name': 'GetCurrentSiteElevation',
            'Value': self.site_height
        })  # write data to GUI
        self.app.mountDataQueue.put({
            'Name': 'GetCurrentSiteLongitude',
            'Value': lon1
        })
        self.app.mountDataQueue.put({
            'Name': 'GetCurrentSiteLatitude',
            'Value': self.site_lat
        })
        self.app.mountDataQueue.put({
            'Name': 'GetFirmwareDate',
            'Value': self.sendCommand('GVD')
        })
        self.app.mountDataQueue.put({
            'Name': 'GetFirmwareNumber',
            'Value': self.sendCommand('GVN')
        })
        self.app.mountDataQueue.put({
            'Name': 'GetFirmwareProductName',
            'Value': self.sendCommand('GVP')
        })
        self.app.mountDataQueue.put({
            'Name': 'GetFirmwareTime',
            'Value': self.sendCommand('GVT')
        })
        self.app.mountDataQueue.put({
            'Name': 'GetHardwareVersion',
            'Value': self.sendCommand('GVZ')
        })
        self.logger.debug('getStatusOnce  -> FW:{0}'.format(
            self.sendCommand('GVN')))  # firmware version for checking
        self.logger.debug('getStatusOnce  -> Site Lon:{0}'.format(
            self.site_lon))  # site lon
        self.logger.debug('getStatusOnce  -> Site Lat:{0}'.format(
            self.site_lat))  # site lat
        self.logger.debug('getStatusOnce  -> Site Height:{0}'.format(
            self.site_height))  # site height

    def setupDriver(self):
        try:
            self.chooser = Dispatch('ASCOM.Utilities.Chooser')
            self.chooser.DeviceType = 'Telescope'
            self.driverName = self.chooser.Choose(self.driverName)
            self.logger.debug('setupDriverMoun-> driver chosen:{0}'.format(
                self.driverName))
            if self.driverName == 'ASCOM.FrejvallGM.Telescope':
                self.driver_real = True
            else:
                self.driver_real = False
            self.connected = False  # run the driver setup dialog
        except Exception as e:  # general exception
            self.app.messageQueue.put(
                'Driver Exception in setupMount')  # write to gui
            self.logger.error(
                'setupDriver Mount -> general exception:{0}'.format(
                    e))  # write to log
            self.connected = False  # set to disconnected
        finally:  # won't stop the program, continue
            return