File indexing completed on 2024-05-12 15:23:36

 /*
     SPDX-FileCopyrightText: 2016 Jasem Mutlaq <mutlaqja@ikarustech.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "linguider.h"
 
 #include "Options.h"
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QNetworkReply>
 
 namespace Ekos
 {
 LinGuider::LinGuider()
 {
     tcpSocket = new QTcpSocket(this);
 
     rawBuffer.clear();
 
     connect(tcpSocket, SIGNAL(readyRead()), this, SLOT(readLinGuider()));
     connect(tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)), this,
             SLOT(displayError(QAbstractSocket::SocketError)));
 
     connect(tcpSocket, SIGNAL(connected()), this, SLOT(onConnected()));
 
     deviationTimer.setInterval(1000);
     connect(&deviationTimer, &QTimer::timeout, this, [&]()
     {
         sendCommand(GET_RA_DEC_DRIFT);
     });
 }
 
 bool LinGuider::Connect()
 {
     if (connection == DISCONNECTED)
     {
         rawBuffer.clear();
         connection = CONNECTING;
         tcpSocket->connectToHost(Options::linGuiderHost(), Options::linGuiderPort());
     }
     // Already connected, let's connect equipment
     else
         emit newStatus(GUIDE_CONNECTED);
 
     return true;
 }
 
 bool LinGuider::Disconnect()
 {
     rawBuffer.clear();
     connection = DISCONNECTED;
     tcpSocket->disconnectFromHost();
 
     emit newStatus(GUIDE_DISCONNECTED);
 
     return true;
 }
 
 void LinGuider::displayError(QAbstractSocket::SocketError socketError)
 {
     switch (socketError)
     {
         case QAbstractSocket::RemoteHostClosedError:
             break;
         case QAbstractSocket::HostNotFoundError:
             emit newLog(i18n("The host was not found. Please check the host name and port settings in Guide options."));
             emit newStatus(GUIDE_DISCONNECTED);
             break;
         case QAbstractSocket::ConnectionRefusedError:
             emit newLog(i18n("The connection was refused by the peer. Make sure the LinGuider is running, and check "
                              "that the host name and port settings are correct."));
             emit newStatus(GUIDE_DISCONNECTED);
             break;
         default:
             emit newLog(i18n("The following error occurred: %1.", tcpSocket->errorString()));
     }
 
     connection = DISCONNECTED;
 }
 
 void LinGuider::readLinGuider()
 {
     while (tcpSocket->atEnd() == false)
     {
         rawBuffer += tcpSocket->readAll();
 
         while (1)
         {
             if (rawBuffer.count() < 8)
                 break;
 
             if (Options::guideLogging())
                 qDebug() << Q_FUNC_INFO << "Guide:" << rawBuffer;
 
             qint16 magicNumber = *(reinterpret_cast<qint16 *>(rawBuffer.data()));
             if (magicNumber != 0x02)
             {
                 emit newLog(i18n("Invalid response."));
                 rawBuffer = rawBuffer.mid(1);
                 continue;
             }
 
             qint16 command = *(reinterpret_cast<qint16 *>(rawBuffer.data() + 2));
             if (command < GET_VER || command > GET_RA_DEC_DRIFT)
             {
                 emit newLog(i18n("Invalid response."));
                 rawBuffer = rawBuffer.mid(1);
                 continue;
             }
 
             qint16 datalen = *(reinterpret_cast<qint16 *>(rawBuffer.data() + 4));
             if (rawBuffer.count() < datalen + 8)
                 break;
 
             QString reply = rawBuffer.mid(8, datalen);
             processResponse(static_cast<LinGuiderCommand>(command), reply);
             rawBuffer = rawBuffer.mid(8 + datalen);
         }
     }
 }
 
 void LinGuider::processResponse(LinGuiderCommand command, const QString &reply)
 {
     if (reply == "Error: Guiding not started.")
     {
         state = IDLE;
         emit newStatus(GUIDE_ABORTED);
         deviationTimer.stop();
         return;
     }
 
     switch (command)
     {
         case GET_VER:
             emit newLog(i18n("Connected to LinGuider %1", reply));
             if (reply < "v.4.1.0")
             {
                 emit newLog(
                     i18n("Only LinGuider v4.1.0 or higher is supported. Please upgrade LinGuider and try again."));
                 Disconnect();
             }
 
             sendCommand(GET_GUIDER_STATE);
             break;
 
         case GET_GUIDER_STATE:
             if (reply == "GUIDING")
             {
                 state = GUIDING;
                 emit newStatus(GUIDE_GUIDING);
                 deviationTimer.start();
             }
             else
             {
                 state = IDLE;
                 deviationTimer.stop();
             }
             break;
 
         case FIND_STAR:
         {
             emit newLog(i18n("Auto star selected %1", reply));
             QStringList pos = reply.split(' ');
             if (pos.count() == 2)
             {
                 starCenter = reply;
                 sendCommand(SET_GUIDER_RETICLE_POS, reply);
             }
             else
             {
                 emit newLog(i18n("Failed to process star position."));
                 emit newStatus(GUIDE_CALIBRATION_ERROR);
             }
         }
         break;
 
         case SET_GUIDER_RETICLE_POS:
             if (reply == "OK")
             {
                 sendCommand(SET_GUIDER_SQUARE_POS, starCenter);
             }
             else
             {
                 emit newLog(i18n("Failed to set guider reticle position."));
                 emit newStatus(GUIDE_CALIBRATION_ERROR);
             }
             break;
 
         case SET_GUIDER_SQUARE_POS:
             if (reply == "OK")
             {
                 emit newStatus(GUIDE_CALIBRATION_SUCCESS);
             }
             else
             {
                 emit newLog(i18n("Failed to set guider square position."));
                 emit newStatus(GUIDE_CALIBRATION_ERROR);
             }
             break;
 
         case GUIDER:
             if (reply == "OK")
             {
                 if (state == IDLE)
                 {
                     emit newStatus(GUIDE_GUIDING);
                     state = GUIDING;
 
                     deviationTimer.start();
                 }
                 else
                 {
                     emit newStatus(GUIDE_IDLE);
                     state = IDLE;
 
                     deviationTimer.stop();
                 }
             }
             else
             {
                 if (state == IDLE)
                     emit newLog(i18n("Failed to start guider."));
                 else
                     emit newLog(i18n("Failed to stop guider."));
             }
             break;
 
         case GET_RA_DEC_DRIFT:
         {
             if (state != GUIDING)
             {
                 state = GUIDING;
                 emit newStatus(GUIDE_GUIDING);
             }
 
             QStringList pos = reply.split(' ');
             if (pos.count() == 2)
             {
                 bool raOK = false, deOK = false;
 
                 double raDev = pos[0].toDouble(&raOK);
                 double deDev = pos[1].toDouble(&deOK);
 
                 if (raOK && deOK)
                     emit newAxisDelta(raDev, deDev);
             }
             else
             {
                 emit newLog(i18n("Failed to get RA/DEC Drift."));
             }
         }
         break;
 
         case SET_DITHERING_RANGE:
             if (reply == "OK")
             {
                 sendCommand(DITHER);
 
                 deviationTimer.stop();
             }
             else
             {
                 emit newLog(i18n("Failed to set dither range."));
             }
             break;
 
         case DITHER:
             if (reply == "Long time cmd finished")
                 emit newStatus(GUIDE_DITHERING_SUCCESS);
             else
                 emit newStatus(GUIDE_DITHERING_ERROR);
 
             state = GUIDING;
             deviationTimer.start();
             break;
 
         default:
             break;
     }
 }
 
 void LinGuider::onConnected()
 {
     connection = CONNECTED;
 
     emit newStatus(GUIDE_CONNECTED);
     // Get version
 
     sendCommand(GET_VER);
 }
 
 void LinGuider::sendCommand(LinGuiderCommand command, const QString &args)
 {
     // Command format: Magic Number (0x00 0x02), cmd (2 bytes), len_of_param (4 bytes), param (ascii)
 
     int size = 8 + args.size();
 
     QByteArray cmd(size, 0);
 
     // Magic number
     cmd[0] = 0x02;
     cmd[1] = 0x00;
 
     // Command
     cmd[2] = command;
     cmd[3] = 0x00;
 
     // Len
     qint32 len = args.size();
     memcpy(cmd.data() + 4, &len, 4);
 
     // Params
     if (args.isEmpty() == false)
         memcpy(cmd.data() + 8, args.toLatin1().data(), args.size());
 
     tcpSocket->write(cmd);
 }
 
 bool LinGuider::calibrate()
 {
     // Let's start calibration. It is already calibrated but in this step we auto-select and star and set the square
     emit newStatus(Ekos::GUIDE_CALIBRATING);
 
     sendCommand(FIND_STAR);
 
     return true;
 }
 
 bool LinGuider::guide()
 {
     sendCommand(GUIDER, "start");
     return true;
 }
 
 bool LinGuider::abort()
 {
     sendCommand(GUIDER, "stop");
     return true;
 }
 
 bool LinGuider::suspend()
 {
     return abort();
 }
 
 bool LinGuider::resume()
 {
     return guide();
 }
 
 bool LinGuider::dither(double pixels)
 {
     QString pixelsString = QString::number(pixels, 'f', 2);
     QString args         = QString("%1 %2").arg(pixelsString, pixelsString);
 
     sendCommand(SET_DITHERING_RANGE, args);
 
     return true;
 }
 }