2018-06-19 19:58:52 +00:00
|
|
|
#ifndef RIGCOMMANDER_H
|
|
|
|
#define RIGCOMMANDER_H
|
|
|
|
|
|
|
|
#include <QObject>
|
2021-11-22 10:37:21 +00:00
|
|
|
#include <QMutexLocker>
|
2023-04-23 20:29:44 +00:00
|
|
|
#include <QSettings>
|
2023-05-03 12:38:06 +00:00
|
|
|
#include <QRegularExpression>
|
2021-02-10 17:32:56 +00:00
|
|
|
#include <QDebug>
|
2018-06-19 19:58:52 +00:00
|
|
|
|
2022-11-27 04:45:32 +00:00
|
|
|
#include "wfviewtypes.h"
|
2018-06-19 19:58:52 +00:00
|
|
|
#include "commhandler.h"
|
2021-03-04 20:19:05 +00:00
|
|
|
#include "pttyhandler.h"
|
2021-02-10 17:32:56 +00:00
|
|
|
#include "udphandler.h"
|
2018-11-24 08:10:05 +00:00
|
|
|
#include "rigidentities.h"
|
2021-03-31 06:37:35 +00:00
|
|
|
#include "repeaterattributes.h"
|
2021-05-27 13:20:53 +00:00
|
|
|
#include "freqmemory.h"
|
2022-03-23 10:12:42 +00:00
|
|
|
#include "tcpserver.h"
|
2023-05-11 23:24:01 +00:00
|
|
|
#include "cachingqueue.h"
|
2018-06-19 19:58:52 +00:00
|
|
|
|
|
|
|
// This file figures out what to send to the comm and also
|
|
|
|
// parses returns into useful things.
|
|
|
|
|
2018-11-16 22:08:21 +00:00
|
|
|
// 0xE1 is new default, 0xE0 was before.
|
|
|
|
// note: using a define because switch case doesn't even work with const unsigned char. Surprised me.
|
|
|
|
#define compCivAddr 0xE1
|
|
|
|
|
2023-04-24 07:37:10 +00:00
|
|
|
//#define DEBUG_PARSE // Enable to output Info messages every 10s with command parse timing.
|
|
|
|
|
2023-04-27 18:56:25 +00:00
|
|
|
typedef QHash<unsigned char, QString> rigTypedef;
|
|
|
|
|
2018-06-19 19:58:52 +00:00
|
|
|
class rigCommander : public QObject
|
|
|
|
{
|
|
|
|
Q_OBJECT
|
|
|
|
|
|
|
|
public:
|
2022-05-08 18:31:05 +00:00
|
|
|
explicit rigCommander(QObject* parent=nullptr);
|
|
|
|
explicit rigCommander(quint8 guid[GUIDLEN], QObject* parent = nullptr);
|
2018-06-19 19:58:52 +00:00
|
|
|
~rigCommander();
|
|
|
|
|
2021-05-01 05:15:30 +00:00
|
|
|
bool usingLAN();
|
|
|
|
|
2022-01-26 09:49:52 +00:00
|
|
|
quint8* getGUID();
|
|
|
|
|
2018-06-19 19:58:52 +00:00
|
|
|
public slots:
|
|
|
|
void process();
|
2023-04-27 18:56:25 +00:00
|
|
|
void commSetup(rigTypedef rigList, unsigned char rigCivAddr, QString rigSerialPort, quint32 rigBaudRate, QString vsp, quint16 tcp, quint8 wf);
|
|
|
|
void commSetup(rigTypedef rigList, unsigned char rigCivAddr, udpPreferences prefs, audioSetup rxSetup, audioSetup txSetup, QString vsp, quint16 tcp);
|
2021-02-10 17:32:56 +00:00
|
|
|
void closeComm();
|
2022-01-04 18:34:34 +00:00
|
|
|
void setRTSforPTT(bool enabled);
|
2018-06-19 19:58:52 +00:00
|
|
|
|
2021-04-20 05:55:39 +00:00
|
|
|
// Power:
|
|
|
|
void powerOn();
|
|
|
|
void powerOff();
|
|
|
|
|
2021-04-04 07:36:21 +00:00
|
|
|
|
|
|
|
// Rig ID and CIV:
|
2018-11-20 07:42:34 +00:00
|
|
|
void getRigID();
|
2021-02-10 17:32:56 +00:00
|
|
|
void findRigs();
|
2021-11-07 06:59:03 +00:00
|
|
|
void setRigID(unsigned char rigID);
|
2018-06-19 19:58:52 +00:00
|
|
|
void setCIVAddr(unsigned char civAddr);
|
2021-04-04 07:36:21 +00:00
|
|
|
|
|
|
|
// UDP:
|
2021-02-28 20:10:07 +00:00
|
|
|
void handleNewData(const QByteArray& data);
|
2021-03-01 19:53:12 +00:00
|
|
|
void receiveAudioData(const audioPacket& data);
|
2023-01-05 19:37:53 +00:00
|
|
|
void handlePortError(errorType err);
|
2021-02-27 00:37:00 +00:00
|
|
|
void changeLatency(const quint16 value);
|
2021-04-04 07:36:21 +00:00
|
|
|
void dataFromServer(QByteArray data);
|
2021-05-21 15:30:52 +00:00
|
|
|
void receiveBaudRate(quint32 baudrate);
|
2021-04-04 07:36:21 +00:00
|
|
|
|
|
|
|
// Housekeeping:
|
2022-01-22 15:12:36 +00:00
|
|
|
void handleStatusUpdate(const networkStatus status);
|
2022-08-24 05:24:05 +00:00
|
|
|
void handleNetworkAudioLevels(networkAudioLevels);
|
2022-01-21 19:23:32 +00:00
|
|
|
void radioSelection(QList<radio_cap_packet> radios);
|
2023-12-18 15:48:17 +00:00
|
|
|
void radioUsage(quint8 radio, bool admin, quint8 busy, QString name, QString ip);
|
2022-01-23 17:54:40 +00:00
|
|
|
void setCurrentRadio(quint8 radio);
|
2018-06-19 19:58:52 +00:00
|
|
|
void getDebug();
|
2024-01-27 22:13:47 +00:00
|
|
|
void receiveCommand(funcs func, QVariant value, uchar vfo);
|
2023-11-26 16:29:22 +00:00
|
|
|
void setAfGain(unsigned char level);
|
2018-06-19 19:58:52 +00:00
|
|
|
|
|
|
|
signals:
|
2021-04-04 07:36:21 +00:00
|
|
|
// Communication:
|
2021-02-10 17:32:56 +00:00
|
|
|
void commReady();
|
2023-01-05 19:37:53 +00:00
|
|
|
void havePortError(errorType err);
|
2022-01-22 15:12:36 +00:00
|
|
|
void haveStatusUpdate(const networkStatus status);
|
2022-08-24 05:24:05 +00:00
|
|
|
void haveNetworkAudioLevels(const networkAudioLevels l);
|
2021-04-04 07:36:21 +00:00
|
|
|
void dataForComm(const QByteArray &outData);
|
2021-11-06 06:21:36 +00:00
|
|
|
void toggleRTS(bool rtsOn);
|
2023-05-08 12:26:45 +00:00
|
|
|
void setHalfDuplex(bool en);
|
2021-04-04 07:36:21 +00:00
|
|
|
|
|
|
|
// UDP:
|
|
|
|
void haveChangeLatency(quint16 value);
|
|
|
|
void haveDataForServer(QByteArray outData);
|
|
|
|
void haveAudioData(audioPacket data);
|
|
|
|
void initUdpHandler();
|
|
|
|
void haveSetVolume(unsigned char level);
|
2021-05-21 15:30:52 +00:00
|
|
|
void haveBaudRate(quint32 baudrate);
|
2021-04-04 07:36:21 +00:00
|
|
|
|
|
|
|
// Spectrum:
|
|
|
|
void haveSpectrumData(QByteArray spectrum, double startFreq, double endFreq); // pass along data to UI
|
2018-06-19 19:58:52 +00:00
|
|
|
void haveSpectrumBounds();
|
2021-04-11 07:42:25 +00:00
|
|
|
void haveScopeSpan(freqt span, bool isSub);
|
2023-05-15 12:47:45 +00:00
|
|
|
void havespectrumMode_t(spectrumMode_t spectmode);
|
2018-12-18 22:34:04 +00:00
|
|
|
void haveScopeEdge(char edge);
|
2021-02-15 23:17:48 +00:00
|
|
|
|
2021-04-04 07:36:21 +00:00
|
|
|
// Rig ID:
|
|
|
|
void haveRigID(rigCapabilities rigCaps);
|
|
|
|
void discoveredRigID(rigCapabilities rigCaps);
|
|
|
|
|
|
|
|
// Repeater:
|
2023-05-15 12:47:45 +00:00
|
|
|
void haveDuplexMode(duplexMode_t);
|
|
|
|
void haveRptAccessMode(rptAccessTxRx_t ratr);
|
2021-04-04 07:36:21 +00:00
|
|
|
void haveTone(quint16 tone);
|
|
|
|
void haveTSQL(quint16 tsql);
|
2021-04-05 06:33:56 +00:00
|
|
|
void haveDTCS(quint16 dcscode, bool tinv, bool rinv);
|
2023-01-28 05:42:57 +00:00
|
|
|
void haveRptOffsetFrequency(freqt f);
|
2023-05-01 20:56:52 +00:00
|
|
|
void haveMemory(memoryType mem);
|
2021-04-04 07:36:21 +00:00
|
|
|
|
|
|
|
// Levels:
|
2018-11-17 06:19:44 +00:00
|
|
|
void haveAfGain(unsigned char level);
|
2021-04-04 07:36:21 +00:00
|
|
|
// Housekeeping:
|
2022-01-21 19:23:32 +00:00
|
|
|
void requestRadioSelection(QList<radio_cap_packet> radios);
|
2023-12-18 15:48:17 +00:00
|
|
|
void setRadioUsage(quint8 radio, bool admin, quint8 busy, QString user, QString ip);
|
2022-01-23 17:54:40 +00:00
|
|
|
void selectedRadio(quint8 radio);
|
2021-04-04 07:36:21 +00:00
|
|
|
void getMoreDebug();
|
|
|
|
void finished();
|
2023-05-15 09:53:52 +00:00
|
|
|
void haveReceivedValue(funcs func, QVariant value);
|
2018-06-19 19:58:52 +00:00
|
|
|
|
|
|
|
private:
|
2023-05-11 23:24:01 +00:00
|
|
|
void commonSetup();
|
2024-01-27 22:13:47 +00:00
|
|
|
|
2018-06-19 19:58:52 +00:00
|
|
|
void parseData(QByteArray data); // new data come here
|
2023-01-25 08:15:20 +00:00
|
|
|
void parseCommand(); // Entry point for complete commands
|
2021-02-16 06:33:21 +00:00
|
|
|
unsigned char bcdHexToUChar(unsigned char in);
|
|
|
|
unsigned char bcdHexToUChar(unsigned char hundreds, unsigned char tensunits);
|
|
|
|
unsigned int bcdHexToUInt(unsigned char hundreds, unsigned char tensunits);
|
2023-05-11 23:24:01 +00:00
|
|
|
QByteArray bcdEncodeChar(unsigned char num);
|
2021-02-11 08:33:25 +00:00
|
|
|
QByteArray bcdEncodeInt(unsigned int);
|
2023-05-15 09:53:52 +00:00
|
|
|
QByteArray setMemory(memoryType mem);
|
|
|
|
freqt parseFrequency();
|
2021-03-22 07:11:43 +00:00
|
|
|
freqt parseFrequency(QByteArray data, unsigned char lastPosition); // supply index where Mhz is found
|
2023-09-22 18:06:09 +00:00
|
|
|
|
2024-01-29 14:20:31 +00:00
|
|
|
freqt parseFreqData(QByteArray data, uchar vfo);
|
2023-05-04 20:55:40 +00:00
|
|
|
quint64 parseFreqDataToInt(QByteArray data);
|
2023-01-28 05:42:57 +00:00
|
|
|
freqt parseFrequencyRptOffset(QByteArray data);
|
2023-05-15 09:53:52 +00:00
|
|
|
bool parseMemory(QVector<memParserFormat>* memParser, memoryType* mem);
|
2023-01-28 05:42:57 +00:00
|
|
|
QByteArray makeFreqPayloadRptOffset(freqt freq);
|
2018-06-19 19:58:52 +00:00
|
|
|
QByteArray makeFreqPayload(double frequency);
|
2021-03-22 07:11:43 +00:00
|
|
|
QByteArray makeFreqPayload(freqt freq);
|
2021-04-05 06:33:56 +00:00
|
|
|
QByteArray encodeTone(quint16 tone, bool tinv, bool rinv);
|
|
|
|
QByteArray encodeTone(quint16 tone);
|
2024-01-27 22:13:47 +00:00
|
|
|
|
2023-05-15 09:53:52 +00:00
|
|
|
toneInfo decodeTone(QByteArray eTone);
|
|
|
|
//quint16 decodeTone(QByteArray eTone, bool &tinv, bool &rinv);
|
2024-01-29 14:20:31 +00:00
|
|
|
uchar makeFilterWidth(ushort width, uchar vfo);
|
2023-05-11 23:24:01 +00:00
|
|
|
|
2021-04-05 06:33:56 +00:00
|
|
|
|
2022-08-24 05:24:05 +00:00
|
|
|
unsigned char audioLevelRxMean[50];
|
|
|
|
unsigned char audioLevelRxPeak[50];
|
|
|
|
unsigned char audioLevelTxMean[50];
|
|
|
|
unsigned char audioLevelTxPeak[50];
|
|
|
|
|
2024-01-29 14:20:31 +00:00
|
|
|
modeInfo parseMode(quint8 mode, quint8 filter, uchar vfo);
|
|
|
|
bool parseSpectrum(scopeData& d, uchar vfo);
|
|
|
|
bool getCommand(funcs func, QByteArray& payload, int value=INT_MIN, uchar vfo=0);
|
2023-12-24 16:35:49 +00:00
|
|
|
|
2021-02-17 08:00:28 +00:00
|
|
|
QByteArray getLANAddr();
|
|
|
|
QByteArray getUSBAddr();
|
2021-02-20 08:05:23 +00:00
|
|
|
QByteArray getACCAddr(unsigned char ab);
|
2018-06-19 19:58:52 +00:00
|
|
|
void sendDataOut();
|
|
|
|
void prepDataAndSend(QByteArray data);
|
|
|
|
void debugMe();
|
2021-02-17 08:00:28 +00:00
|
|
|
void printHex(const QByteArray &pdata);
|
2018-06-19 19:58:52 +00:00
|
|
|
void printHex(const QByteArray &pdata, bool printVert, bool printHoriz);
|
2023-09-26 11:58:37 +00:00
|
|
|
|
2021-06-19 05:45:12 +00:00
|
|
|
centerSpanData createScopeCenter(centerSpansType s, QString name);
|
2021-02-17 08:00:28 +00:00
|
|
|
|
2021-03-04 20:19:05 +00:00
|
|
|
commHandler* comm = Q_NULLPTR;
|
|
|
|
pttyHandler* ptty = Q_NULLPTR;
|
2022-03-23 10:12:42 +00:00
|
|
|
tcpServer* tcp = Q_NULLPTR;
|
2021-02-10 17:32:56 +00:00
|
|
|
udpHandler* udp=Q_NULLPTR;
|
2021-02-21 14:53:42 +00:00
|
|
|
QThread* udpHandlerThread = Q_NULLPTR;
|
|
|
|
|
2021-02-10 17:32:56 +00:00
|
|
|
void determineRigCaps();
|
2018-06-19 19:58:52 +00:00
|
|
|
QByteArray payloadIn;
|
|
|
|
QByteArray echoPerfix;
|
|
|
|
QByteArray replyPrefix;
|
|
|
|
QByteArray genericReplyPrefix;
|
|
|
|
|
|
|
|
QByteArray payloadPrefix;
|
|
|
|
QByteArray payloadSuffix;
|
|
|
|
|
|
|
|
QByteArray rigData;
|
|
|
|
|
|
|
|
QByteArray spectrumLine;
|
2023-05-24 18:50:01 +00:00
|
|
|
//double spectrumStartFreq;
|
|
|
|
//double spectrumEndFreq;
|
2018-06-19 19:58:52 +00:00
|
|
|
|
2021-02-10 17:32:56 +00:00
|
|
|
struct rigCapabilities rigCaps;
|
2021-04-19 16:49:51 +00:00
|
|
|
|
2023-04-23 20:29:44 +00:00
|
|
|
bool haveRigCaps=false;
|
2023-05-24 18:50:01 +00:00
|
|
|
quint8 model = 0; // Was model_kind but that makes no sense when users can create their own rigs!
|
2021-02-10 17:32:56 +00:00
|
|
|
quint8 spectSeqMax;
|
|
|
|
quint16 spectAmpMax;
|
|
|
|
quint16 spectLenMax;
|
2023-05-15 12:47:45 +00:00
|
|
|
spectrumMode_t oldScopeMode;
|
2021-02-10 17:32:56 +00:00
|
|
|
|
|
|
|
bool usingNativeLAN; // indicates using OEM LAN connection (705,7610,9700,7850)
|
|
|
|
bool lookingForRig;
|
|
|
|
bool foundRig;
|
2018-06-19 19:58:52 +00:00
|
|
|
|
|
|
|
double frequencyMhz;
|
2021-04-04 07:36:21 +00:00
|
|
|
unsigned char civAddr;
|
2021-02-10 17:32:56 +00:00
|
|
|
unsigned char incomingCIVAddr; // place to store the incoming CIV.
|
2018-11-07 23:54:03 +00:00
|
|
|
bool pttAllowed;
|
2022-01-04 18:34:34 +00:00
|
|
|
bool useRTSforPTT_isSet = false;
|
|
|
|
bool useRTSforPTT_manual = false;
|
|
|
|
|
2023-09-23 10:37:55 +00:00
|
|
|
scopeData mainScopeData;
|
|
|
|
scopeData subScopeData;
|
2018-06-19 19:58:52 +00:00
|
|
|
|
2021-02-10 17:32:56 +00:00
|
|
|
QString rigSerialPort;
|
|
|
|
quint32 rigBaudRate;
|
|
|
|
|
2024-02-07 13:06:23 +00:00
|
|
|
QByteArray lastCommandToRig;
|
|
|
|
|
2021-02-10 17:32:56 +00:00
|
|
|
QString ip;
|
|
|
|
int cport;
|
|
|
|
int sport;
|
|
|
|
int aport;
|
|
|
|
QString username;
|
|
|
|
QString password;
|
|
|
|
|
|
|
|
QString serialPortError;
|
2022-01-04 18:34:34 +00:00
|
|
|
unsigned char localVolume=0;
|
2022-01-29 22:50:58 +00:00
|
|
|
quint8 guid[GUIDLEN] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
|
2023-04-23 20:29:44 +00:00
|
|
|
QHash<unsigned char,QString> rigList;
|
2018-06-19 19:58:52 +00:00
|
|
|
|
2023-05-03 12:38:06 +00:00
|
|
|
quint64 pow10[12] = {
|
|
|
|
1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000
|
|
|
|
};
|
|
|
|
|
2023-05-11 23:24:01 +00:00
|
|
|
cachingQueue* queue;
|
|
|
|
|
2023-04-24 07:37:10 +00:00
|
|
|
#ifdef DEBUG_PARSE
|
2023-04-23 20:29:44 +00:00
|
|
|
quint64 averageParseTime=0;
|
|
|
|
int numParseSamples = 0;
|
|
|
|
int lowParse=9999;
|
|
|
|
int highParse=0;
|
|
|
|
QTime lastParseReport = QTime::currentTime();
|
2023-04-24 07:37:10 +00:00
|
|
|
#endif
|
2018-06-19 19:58:52 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif // RIGCOMMANDER_H
|