2018-06-19 19:58:52 +00:00
# include "rigcommander.h"
# include <QDebug>
2018-11-24 08:10:05 +00:00
# include "rigidentities.h"
2021-02-23 21:21:22 +00:00
# include "logcategories.h"
2018-11-24 08:10:05 +00:00
2022-03-23 15:45:51 +00:00
// Copyright 2017-2020 Elliott H. Liggett
2018-11-16 22:08:21 +00:00
// This file parses data from the radio and also forms commands to the radio.
// The radio physical interface is handled by the commHandler() instance "comm"
2018-06-19 19:58:52 +00:00
//
// See here for a wonderful CI-V overview:
// http://www.plicht.de/ekki/civ/civ-p0a.html
//
// The IC-7300 "full" manual also contains a command reference.
// How to make spectrum display stop using rigctl:
2021-02-27 20:18:26 +00:00
// echo "w \0xFE\0xFE\0x94\0xE0\0x27\0x11\0x00\0xFD" | rigctl -m 3073 -r /dev/ttyUSB0 -s 115200 -vvvvv
2018-06-19 19:58:52 +00:00
// Note: When sending \x00, must use QByteArray.setRawData()
2022-05-08 18:31:05 +00:00
rigCommander : : rigCommander ( QObject * parent ) : QObject ( parent )
2021-02-10 17:32:56 +00:00
{
2022-01-26 09:49:52 +00:00
qInfo ( logRig ( ) ) < < " creating instance of rigCommander() " ;
state . set ( SCOPEFUNC , true , false ) ;
}
2022-05-08 18:31:05 +00:00
rigCommander : : rigCommander ( quint8 guid [ GUIDLEN ] , QObject * parent ) : QObject ( parent )
2022-01-26 09:49:52 +00:00
{
qInfo ( logRig ( ) ) < < " creating instance of rigCommander() " ;
state . set ( SCOPEFUNC , true , false ) ;
2022-01-29 22:50:58 +00:00
memcpy ( this - > guid , guid , GUIDLEN ) ;
2021-02-10 17:32:56 +00:00
}
rigCommander : : ~ rigCommander ( )
{
2022-01-26 09:49:52 +00:00
qInfo ( logRig ( ) ) < < " closing instance of rigCommander() " ;
2021-02-10 17:32:56 +00:00
closeComm ( ) ;
}
2018-06-19 19:58:52 +00:00
2021-02-10 17:32:56 +00:00
2022-04-18 19:29:50 +00:00
void rigCommander : : commSetup ( unsigned char rigCivAddr , QString rigSerialPort , quint32 rigBaudRate , QString vsp , quint16 tcpPort , quint8 wf )
2018-06-19 19:58:52 +00:00
{
// construct
2018-11-07 23:54:03 +00:00
// TODO: Bring this parameter and the comm port from the UI.
2018-11-27 07:10:23 +00:00
// Keep in hex in the UI as is done with other CIV apps.
2018-11-29 21:41:42 +00:00
// civAddr = 0x94; // address of the radio. Decimal is 148.
civAddr = rigCivAddr ; // address of the radio. Decimal is 148.
2021-02-10 17:32:56 +00:00
usingNativeLAN = false ;
2022-04-18 19:29:50 +00:00
2022-04-28 09:52:46 +00:00
//qInfo(logRig()) << "Opening connection to Rig:" << QString("0x%1").arg((unsigned char)rigCivAddr,0,16) << "on serial port" << rigSerialPort << "at baud rate" << rigBaudRate;
2021-02-10 17:32:56 +00:00
// ---
setup ( ) ;
// ---
2018-11-16 22:08:21 +00:00
2021-02-10 17:32:56 +00:00
this - > rigSerialPort = rigSerialPort ;
this - > rigBaudRate = rigBaudRate ;
2022-01-26 09:49:52 +00:00
rigCaps . baudRate = rigBaudRate ;
2018-11-27 07:10:23 +00:00
2022-05-08 18:31:05 +00:00
comm = new commHandler ( rigSerialPort , rigBaudRate , wf , this ) ;
ptty = new pttyHandler ( vsp , this ) ;
2018-06-19 19:58:52 +00:00
2022-04-08 13:40:05 +00:00
if ( tcpPort > 0 ) {
tcp = new tcpServer ( this ) ;
tcp - > startServer ( tcpPort ) ;
}
2022-03-23 10:12:42 +00:00
2018-06-19 19:58:52 +00:00
// data from the comm port to the program:
connect ( comm , SIGNAL ( haveDataFromPort ( QByteArray ) ) , this , SLOT ( handleNewData ( QByteArray ) ) ) ;
2021-03-04 20:19:05 +00:00
// data from the ptty to the rig:
connect ( ptty , SIGNAL ( haveDataFromPort ( QByteArray ) ) , comm , SLOT ( receiveDataFromUserToRig ( QByteArray ) ) ) ;
2022-03-23 10:12:42 +00:00
2018-06-19 19:58:52 +00:00
// data from the program to the comm port:
connect ( this , SIGNAL ( dataForComm ( QByteArray ) ) , comm , SLOT ( receiveDataFromUserToRig ( QByteArray ) ) ) ;
2022-04-08 13:40:05 +00:00
if ( tcpPort > 0 ) {
// data from the tcp port to the rig:
connect ( tcp , SIGNAL ( receiveData ( QByteArray ) ) , comm , SLOT ( receiveDataFromUserToRig ( QByteArray ) ) ) ;
connect ( comm , SIGNAL ( haveDataFromPort ( QByteArray ) ) , tcp , SLOT ( sendData ( QByteArray ) ) ) ;
}
2021-11-06 06:21:36 +00:00
connect ( this , SIGNAL ( toggleRTS ( bool ) ) , comm , SLOT ( setRTS ( bool ) ) ) ;
2018-06-19 19:58:52 +00:00
2021-03-04 20:19:05 +00:00
// data from the rig to the ptty:
2021-03-05 12:53:23 +00:00
connect ( comm , SIGNAL ( haveDataFromPort ( QByteArray ) ) , ptty , SLOT ( receiveDataFromRigToPtty ( QByteArray ) ) ) ;
2021-03-04 20:19:05 +00:00
2021-02-10 17:32:56 +00:00
connect ( comm , SIGNAL ( haveSerialPortError ( QString , QString ) ) , this , SLOT ( handleSerialPortError ( QString , QString ) ) ) ;
2021-03-04 20:19:05 +00:00
connect ( ptty , SIGNAL ( haveSerialPortError ( QString , QString ) ) , this , SLOT ( handleSerialPortError ( QString , QString ) ) ) ;
2021-02-10 17:32:56 +00:00
2018-06-19 19:58:52 +00:00
connect ( this , SIGNAL ( getMoreDebug ( ) ) , comm , SLOT ( debugThis ( ) ) ) ;
2021-03-04 20:19:05 +00:00
connect ( this , SIGNAL ( getMoreDebug ( ) ) , ptty , SLOT ( debugThis ( ) ) ) ;
2021-08-28 23:16:31 +00:00
connect ( this , SIGNAL ( discoveredRigID ( rigCapabilities ) ) , ptty , SLOT ( receiveFoundRigID ( rigCapabilities ) ) ) ;
2021-02-10 17:32:56 +00:00
emit commReady ( ) ;
2021-09-07 17:04:43 +00:00
sendState ( ) ; // Send current rig state to rigctld
2021-02-10 17:32:56 +00:00
}
2022-04-08 13:40:05 +00:00
void rigCommander : : commSetup ( unsigned char rigCivAddr , udpPreferences prefs , audioSetup rxSetup , audioSetup txSetup , QString vsp , quint16 tcpPort )
2021-02-10 17:32:56 +00:00
{
// construct
// TODO: Bring this parameter and the comm port from the UI.
// Keep in hex in the UI as is done with other CIV apps.
// civAddr = 0x94; // address of the radio. Decimal is 148.
civAddr = rigCivAddr ; // address of the radio. Decimal is 148.
usingNativeLAN = true ;
2022-05-05 17:48:45 +00:00
// --
2021-02-10 17:32:56 +00:00
setup ( ) ;
// ---
2022-03-23 10:12:42 +00:00
2021-02-10 17:32:56 +00:00
if ( udp = = Q_NULLPTR ) {
2021-02-21 14:53:42 +00:00
2021-06-04 07:24:26 +00:00
udp = new udpHandler ( prefs , rxSetup , txSetup ) ;
2021-02-21 14:53:42 +00:00
udpHandlerThread = new QThread ( this ) ;
2022-05-02 15:11:35 +00:00
udpHandlerThread - > setObjectName ( " udpHandler() " ) ;
2021-02-21 14:53:42 +00:00
udp - > moveToThread ( udpHandlerThread ) ;
connect ( this , SIGNAL ( initUdpHandler ( ) ) , udp , SLOT ( init ( ) ) ) ;
connect ( udpHandlerThread , SIGNAL ( finished ( ) ) , udp , SLOT ( deleteLater ( ) ) ) ;
udpHandlerThread - > start ( ) ;
emit initUdpHandler ( ) ;
2021-03-05 12:53:23 +00:00
//this->rigSerialPort = rigSerialPort;
//this->rigBaudRate = rigBaudRate;
2021-03-04 20:19:05 +00:00
2022-05-08 18:31:05 +00:00
ptty = new pttyHandler ( vsp , this ) ;
2021-03-04 20:19:05 +00:00
2022-04-08 13:40:05 +00:00
if ( tcpPort > 0 ) {
tcp = new tcpServer ( this ) ;
tcp - > startServer ( tcpPort ) ;
}
2021-03-05 12:53:23 +00:00
// Data from UDP to the program
2021-02-10 17:32:56 +00:00
connect ( udp , SIGNAL ( haveDataFromPort ( QByteArray ) ) , this , SLOT ( handleNewData ( QByteArray ) ) ) ;
2021-03-05 12:53:23 +00:00
2021-03-04 20:19:05 +00:00
// data from the rig to the ptty:
connect ( udp , SIGNAL ( haveDataFromPort ( QByteArray ) ) , ptty , SLOT ( receiveDataFromRigToPtty ( QByteArray ) ) ) ;
2021-03-05 12:53:23 +00:00
// Audio from UDP
2021-03-01 19:53:12 +00:00
connect ( udp , SIGNAL ( haveAudioData ( audioPacket ) ) , this , SLOT ( receiveAudioData ( audioPacket ) ) ) ;
2021-02-10 17:32:56 +00:00
2021-03-05 12:53:23 +00:00
// data from the program to the rig:
2021-02-10 17:32:56 +00:00
connect ( this , SIGNAL ( dataForComm ( QByteArray ) ) , udp , SLOT ( receiveDataFromUserToRig ( QByteArray ) ) ) ;
2021-03-05 12:53:23 +00:00
2021-03-04 20:19:05 +00:00
// data from the ptty to the rig:
connect ( ptty , SIGNAL ( haveDataFromPort ( QByteArray ) ) , udp , SLOT ( receiveDataFromUserToRig ( QByteArray ) ) ) ;
2022-04-08 13:40:05 +00:00
if ( tcpPort > 0 ) {
// data from the tcp port to the rig:
connect ( tcp , SIGNAL ( receiveData ( QByteArray ) ) , udp , SLOT ( receiveDataFromUserToRig ( QByteArray ) ) ) ;
connect ( udp , SIGNAL ( haveDataFromPort ( QByteArray ) ) , tcp , SLOT ( sendData ( QByteArray ) ) ) ;
}
2022-03-23 10:12:42 +00:00
2021-02-27 00:37:00 +00:00
connect ( this , SIGNAL ( haveChangeLatency ( quint16 ) ) , udp , SLOT ( changeLatency ( quint16 ) ) ) ;
2021-03-22 18:53:34 +00:00
connect ( this , SIGNAL ( haveSetVolume ( unsigned char ) ) , udp , SLOT ( setVolume ( unsigned char ) ) ) ;
2021-05-21 15:30:52 +00:00
connect ( udp , SIGNAL ( haveBaudRate ( quint32 ) ) , this , SLOT ( receiveBaudRate ( quint32 ) ) ) ;
2021-02-10 17:32:56 +00:00
// Connect for errors/alerts
connect ( udp , SIGNAL ( haveNetworkError ( QString , QString ) ) , this , SLOT ( handleSerialPortError ( QString , QString ) ) ) ;
2022-01-22 15:12:36 +00:00
connect ( udp , SIGNAL ( haveNetworkStatus ( networkStatus ) ) , this , SLOT ( handleStatusUpdate ( networkStatus ) ) ) ;
2022-08-24 05:24:05 +00:00
connect ( udp , SIGNAL ( haveNetworkAudioLevels ( networkAudioLevels ) ) , this , SLOT ( handleNetworkAudioLevels ( networkAudioLevels ) ) ) ;
2021-03-04 20:19:05 +00:00
connect ( ptty , SIGNAL ( haveSerialPortError ( QString , QString ) ) , this , SLOT ( handleSerialPortError ( QString , QString ) ) ) ;
connect ( this , SIGNAL ( getMoreDebug ( ) ) , ptty , SLOT ( debugThis ( ) ) ) ;
2021-07-05 23:45:19 +00:00
2021-08-28 23:16:31 +00:00
connect ( this , SIGNAL ( discoveredRigID ( rigCapabilities ) ) , ptty , SLOT ( receiveFoundRigID ( rigCapabilities ) ) ) ;
2022-01-21 19:23:32 +00:00
connect ( udp , SIGNAL ( requestRadioSelection ( QList < radio_cap_packet > ) ) , this , SLOT ( radioSelection ( QList < radio_cap_packet > ) ) ) ;
2022-01-23 17:54:40 +00:00
connect ( udp , SIGNAL ( setRadioUsage ( quint8 , quint8 , QString , QString ) ) , this , SLOT ( radioUsage ( quint8 , quint8 , QString , QString ) ) ) ;
connect ( this , SIGNAL ( selectedRadio ( quint8 ) ) , udp , SLOT ( setCurrentRadio ( quint8 ) ) ) ;
2021-07-05 23:45:19 +00:00
emit haveAfGain ( rxSetup . localAFgain ) ;
2022-01-04 18:34:34 +00:00
localVolume = rxSetup . localAFgain ;
2021-02-10 17:32:56 +00:00
}
// data from the comm port to the program:
emit commReady ( ) ;
2021-08-04 19:49:32 +00:00
sendState ( ) ; // Send current rig state to rigctld
2021-02-10 17:32:56 +00:00
2018-11-07 23:54:03 +00:00
pttAllowed = true ; // This is for developing, set to false for "safe" debugging. Set to true for deployment.
2021-02-10 17:32:56 +00:00
2018-06-19 19:58:52 +00:00
}
2021-02-10 17:32:56 +00:00
void rigCommander : : closeComm ( )
{
2021-05-22 16:02:51 +00:00
qDebug ( logRig ( ) ) < < " Closing rig comms " ;
2021-02-10 17:32:56 +00:00
if ( comm ! = Q_NULLPTR ) {
delete comm ;
}
comm = Q_NULLPTR ;
2021-02-21 14:53:42 +00:00
if ( udpHandlerThread ! = Q_NULLPTR ) {
udpHandlerThread - > quit ( ) ;
udpHandlerThread - > wait ( ) ;
2021-02-10 17:32:56 +00:00
}
udp = Q_NULLPTR ;
2021-03-04 20:19:05 +00:00
if ( ptty ! = Q_NULLPTR ) {
delete ptty ;
}
2021-03-05 12:53:23 +00:00
ptty = Q_NULLPTR ;
2021-02-10 17:32:56 +00:00
}
void rigCommander : : setup ( )
2018-06-19 19:58:52 +00:00
{
2021-02-10 17:32:56 +00:00
// common elements between the two constructors go here:
setCIVAddr ( civAddr ) ;
spectSeqMax = 0 ; // this is now set after rig ID determined
2021-05-30 22:08:22 +00:00
2021-02-10 17:32:56 +00:00
payloadSuffix = QByteArray ( " \xFD " ) ;
lookingForRig = false ;
foundRig = false ;
2021-03-01 05:41:27 +00:00
oldScopeMode = spectModeUnknown ;
2021-02-10 17:32:56 +00:00
pttAllowed = true ; // This is for developing, set to false for "safe" debugging. Set to true for deployment.
2018-06-19 19:58:52 +00:00
}
2021-05-30 22:08:22 +00:00
2018-06-19 19:58:52 +00:00
void rigCommander : : process ( )
{
2021-02-10 17:32:56 +00:00
// new thread enters here. Do nothing but do check for errors.
if ( comm ! = Q_NULLPTR & & comm - > serialError )
{
emit haveSerialPortError ( rigSerialPort , QString ( " Error from commhandler. Check serial port. " ) ) ;
}
}
void rigCommander : : handleSerialPortError ( const QString port , const QString errorText )
{
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < " Error using port " < < port < < " message: " < < errorText ;
2021-02-10 17:32:56 +00:00
emit haveSerialPortError ( port , errorText ) ;
}
2022-01-22 15:12:36 +00:00
void rigCommander : : handleStatusUpdate ( const networkStatus status )
2021-02-10 17:32:56 +00:00
{
2022-01-22 15:12:36 +00:00
emit haveStatusUpdate ( status ) ;
2021-02-10 17:32:56 +00:00
}
2022-08-24 05:24:05 +00:00
void rigCommander : : handleNetworkAudioLevels ( networkAudioLevels l )
{
emit haveNetworkAudioLevels ( l ) ;
}
2021-05-01 05:15:30 +00:00
bool rigCommander : : usingLAN ( )
{
return usingNativeLAN ;
}
2021-05-21 15:30:52 +00:00
void rigCommander : : receiveBaudRate ( quint32 baudrate ) {
2022-01-26 09:49:52 +00:00
rigCaps . baudRate = baudrate ;
2021-05-21 15:30:52 +00:00
emit haveBaudRate ( baudrate ) ;
}
2022-01-04 18:34:34 +00:00
void rigCommander : : setRTSforPTT ( bool enabled )
{
if ( ! usingNativeLAN )
{
useRTSforPTT_isSet = true ;
useRTSforPTT_manual = enabled ;
if ( comm ! = NULL )
{
rigCaps . useRTSforPTT = enabled ;
comm - > setUseRTSforPTT ( enabled ) ;
}
}
}
2021-02-10 17:32:56 +00:00
void rigCommander : : findRigs ( )
{
// This function sends data to 0x00 ("broadcast") to look for any connected rig.
lookingForRig = true ;
foundRig = false ;
QByteArray data ;
QByteArray data2 ;
//data.setRawData("\xFE\xFE\xa2", 3);
data . setRawData ( " \xFE \xFE \x00 " , 3 ) ;
2021-02-22 11:11:08 +00:00
data . append ( ( char ) compCivAddr ) ; // wfview's address, 0xE1
2021-02-10 17:32:56 +00:00
data2 . setRawData ( " \x19 \x00 " , 2 ) ; // get rig ID
data . append ( data2 ) ;
data . append ( payloadSuffix ) ;
emit dataForComm ( data ) ;
2021-11-05 03:17:50 +00:00
// HACK for testing radios that do not respond to rig ID queries:
//this->model = model736;
//this->determineRigCaps();
2021-02-10 17:32:56 +00:00
return ;
2018-06-19 19:58:52 +00:00
}
void rigCommander : : prepDataAndSend ( QByteArray data )
{
data . prepend ( payloadPrefix ) ;
//printHex(data, false, true);
data . append ( payloadSuffix ) ;
2021-05-15 17:53:16 +00:00
2021-03-03 06:11:01 +00:00
if ( data [ 4 ] ! = ' \x15 ' )
{
// We don't print out requests for meter levels
qDebug ( logRig ( ) ) < < " Final payload in rig commander to be sent to rig: " ;
printHex ( data ) ;
}
2021-05-15 17:53:16 +00:00
2018-06-19 19:58:52 +00:00
emit dataForComm ( data ) ;
}
2021-04-20 05:55:39 +00:00
void rigCommander : : powerOn ( )
{
QByteArray payload ;
2022-01-04 18:34:34 +00:00
int numFE = 150 ;
switch ( this - > rigBaudRate ) {
case 57600 :
numFE = 75 ;
break ;
case 38400 :
numFE = 50 ;
break ;
case 19200 :
numFE = 25 ;
break ;
case 9600 :
numFE = 13 ;
break ;
case 4800 :
numFE = 7 ;
break ;
}
for ( int i = 0 ; i < numFE ; i + + )
2021-04-20 05:55:39 +00:00
{
payload . append ( " \xFE " ) ;
}
payload . append ( payloadPrefix ) ; // FE FE 94 E1
payload . append ( " \x18 \x01 " ) ;
payload . append ( payloadSuffix ) ; // FD
qDebug ( logRig ( ) ) < < " Power ON command in rigcommander to be sent to rig: " ;
printHex ( payload ) ;
emit dataForComm ( payload ) ;
}
void rigCommander : : powerOff ( )
{
QByteArray payload ;
payload . setRawData ( " \x18 \x00 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
2018-06-19 19:58:52 +00:00
void rigCommander : : enableSpectOutput ( )
{
QByteArray payload ( " \x27 \x11 \x01 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : disableSpectOutput ( )
{
QByteArray payload ;
payload . setRawData ( " \x27 \x11 \x00 " , 3 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : enableSpectrumDisplay ( )
{
// 27 10 01
QByteArray payload ( " \x27 \x10 \x01 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : disableSpectrumDisplay ( )
{
// 27 10 00
QByteArray payload ;
payload . setRawData ( " \x27 \x10 \x00 " , 3 ) ;
prepDataAndSend ( payload ) ;
}
2021-02-10 17:32:56 +00:00
void rigCommander : : setSpectrumBounds ( double startFreq , double endFreq , unsigned char edgeNumber )
2018-06-19 19:58:52 +00:00
{
2021-02-27 08:05:06 +00:00
if ( ( edgeNumber > 4 ) | | ( ! edgeNumber ) )
2021-02-10 17:32:56 +00:00
{
return ;
}
2018-06-19 19:58:52 +00:00
2021-02-10 17:32:56 +00:00
unsigned char freqRange = 1 ; // 1 = VHF, 2 = UHF, 3 = L-Band
switch ( rigCaps . model )
{
case model9700 :
if ( startFreq > 148 )
{
freqRange + + ;
if ( startFreq > 450 )
{
freqRange + + ;
}
}
break ;
case model705 :
case model7300 :
case model7610 :
case model7850 :
// Some rigs do not go past 60 MHz, but we will not encounter
// requests for those ranges since they are derived from the rig's existing scope range.
// start value of freqRange is 1.
if ( startFreq > 1.6 )
freqRange + + ;
if ( startFreq > 2.0 )
freqRange + + ;
if ( startFreq > 6.0 )
freqRange + + ;
if ( startFreq > 8.0 )
freqRange + + ;
if ( startFreq > 11.0 )
freqRange + + ;
if ( startFreq > 15.0 )
freqRange + + ;
if ( startFreq > 20.0 )
freqRange + + ;
if ( startFreq > 22.0 )
freqRange + + ;
if ( startFreq > 26.0 )
freqRange + + ;
if ( startFreq > 30.0 )
freqRange + + ;
if ( startFreq > 45.0 )
freqRange + + ;
if ( startFreq > 60.0 )
freqRange + + ;
if ( startFreq > 74.8 )
freqRange + + ;
if ( startFreq > 108.0 )
freqRange + + ;
if ( startFreq > 137.0 )
freqRange + + ;
if ( startFreq > 400.0 )
freqRange + + ;
break ;
2021-06-19 05:45:12 +00:00
case modelR8600 :
freqRange = 1 ;
edgeNumber = 1 ;
break ;
2021-02-10 17:32:56 +00:00
default :
return ;
break ;
}
2021-02-27 08:05:06 +00:00
QByteArray lowerEdge = makeFreqPayload ( startFreq ) ;
2021-02-10 17:32:56 +00:00
QByteArray higherEdge = makeFreqPayload ( endFreq ) ;
QByteArray payload ;
payload . setRawData ( " \x27 \x1E " , 2 ) ;
payload . append ( freqRange ) ;
payload . append ( edgeNumber ) ;
payload . append ( lowerEdge ) ;
payload . append ( higherEdge ) ;
prepDataAndSend ( payload ) ;
2018-06-19 19:58:52 +00:00
}
2018-12-18 22:34:04 +00:00
void rigCommander : : getScopeMode ( )
{
// center or fixed
QByteArray payload ;
2021-03-01 05:41:27 +00:00
payload . setRawData ( " \x27 \x14 \x00 " , 3 ) ;
2018-12-18 22:34:04 +00:00
prepDataAndSend ( payload ) ;
}
void rigCommander : : getScopeEdge ( )
{
QByteArray payload ;
payload . setRawData ( " \x27 \x16 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
2018-06-19 19:58:52 +00:00
void rigCommander : : setScopeEdge ( char edge )
{
// 1 2 or 3
// 27 16 00 0X
2021-02-27 04:12:17 +00:00
if ( ( edge < 1 ) | | ( edge > 4 ) )
2018-06-19 19:58:52 +00:00
return ;
QByteArray payload ;
payload . setRawData ( " \x27 \x16 \x00 " , 3 ) ;
payload . append ( edge ) ;
prepDataAndSend ( payload ) ;
}
2018-12-18 22:34:04 +00:00
void rigCommander : : getScopeSpan ( )
2021-04-11 07:42:25 +00:00
{
getScopeSpan ( false ) ;
}
void rigCommander : : getScopeSpan ( bool isSub )
2018-12-18 22:34:04 +00:00
{
QByteArray payload ;
payload . setRawData ( " \x27 \x15 " , 2 ) ;
2021-04-11 07:42:25 +00:00
payload . append ( static_cast < unsigned char > ( isSub ) ) ;
2018-12-18 22:34:04 +00:00
prepDataAndSend ( payload ) ;
}
2018-06-19 19:58:52 +00:00
void rigCommander : : setScopeSpan ( char span )
{
// See ICD, page 165, "19-12".
// 2.5k = 0
// 5k = 2, etc.
2021-06-19 05:45:12 +00:00
if ( ( span < 0 ) | | ( span > 9 ) )
2018-06-19 19:58:52 +00:00
return ;
QByteArray payload ;
double freq ; // MHz
payload . setRawData ( " \x27 \x15 \x00 " , 3 ) ;
// next 6 bytes are the frequency
switch ( span )
{
case 0 :
// 2.5k
freq = 2.5E-3 ;
break ;
case 1 :
// 5k
freq = 5.0E-3 ;
break ;
case 2 :
freq = 10.0E-3 ;
break ;
case 3 :
freq = 25.0E-3 ;
break ;
case 4 :
freq = 50.0E-3 ;
break ;
case 5 :
freq = 100.0E-3 ;
break ;
case 6 :
freq = 250.0E-3 ;
break ;
case 7 :
freq = 500.0E-3 ;
break ;
2021-06-19 05:45:12 +00:00
case 8 :
freq = 1000.0E-3 ;
break ;
case 9 :
freq = 2500.0E-3 ;
break ;
2018-06-19 19:58:52 +00:00
default :
return ;
break ;
}
payload . append ( makeFreqPayload ( freq ) ) ;
payload . append ( " \x00 " ) ;
2018-12-18 22:34:04 +00:00
// printHex(payload, false, true);
2018-06-19 19:58:52 +00:00
prepDataAndSend ( payload ) ;
}
2021-03-01 05:41:27 +00:00
void rigCommander : : setSpectrumMode ( spectrumMode spectMode )
{
QByteArray specModePayload ;
specModePayload . setRawData ( " \x27 \x14 \x00 " , 3 ) ;
specModePayload . append ( static_cast < unsigned char > ( spectMode ) ) ;
prepDataAndSend ( specModePayload ) ;
}
2021-02-16 06:33:21 +00:00
void rigCommander : : getSpectrumRefLevel ( )
{
QByteArray payload ;
payload . setRawData ( " \x27 \x19 \x00 " , 3 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getSpectrumRefLevel ( unsigned char mainSub )
{
QByteArray payload ;
payload . setRawData ( " \x27 \x19 " , 2 ) ;
payload . append ( mainSub ) ;
prepDataAndSend ( payload ) ;
}
2021-02-16 05:40:31 +00:00
void rigCommander : : setSpectrumRefLevel ( int level )
{
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << __func__ << ": Setting scope to level " << level;
2021-02-16 05:40:31 +00:00
QByteArray setting ;
QByteArray number ;
QByteArray pn ;
setting . setRawData ( " \x27 \x19 \x00 " , 3 ) ;
if ( level > = 0 )
{
pn . setRawData ( " \x00 " , 1 ) ;
number = bcdEncodeInt ( level * 10 ) ;
} else {
pn . setRawData ( " \x01 " , 1 ) ;
number = bcdEncodeInt ( ( - level ) * 10 ) ;
}
setting . append ( number ) ;
setting . append ( pn ) ;
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << __func__ << ": scope reference number: " << number << ", PN to: " << pn;
2021-02-16 05:40:31 +00:00
//printHex(setting, false, true);
prepDataAndSend ( setting ) ;
}
2018-12-18 22:34:04 +00:00
void rigCommander : : getSpectrumCenterMode ( )
{
QByteArray specModePayload ;
specModePayload . setRawData ( " \x27 \x14 " , 2 ) ;
prepDataAndSend ( specModePayload ) ;
}
2021-03-01 05:41:27 +00:00
void rigCommander : : getSpectrumMode ( )
{
QByteArray specModePayload ;
specModePayload . setRawData ( " \x27 \x14 " , 2 ) ;
prepDataAndSend ( specModePayload ) ;
}
2021-08-29 10:51:53 +00:00
void rigCommander : : setFrequency ( unsigned char vfo , freqt freq )
2018-06-19 19:58:52 +00:00
{
QByteArray freqPayload = makeFreqPayload ( freq ) ;
QByteArray cmdPayload ;
cmdPayload . append ( freqPayload ) ;
2021-08-29 10:51:53 +00:00
if ( vfo = = 0 ) {
cmdPayload . prepend ( ' \x00 ' ) ;
}
else
{
cmdPayload . prepend ( vfo ) ;
cmdPayload . prepend ( ' \x25 ' ) ;
}
2018-06-20 06:45:56 +00:00
//printHex(cmdPayload, false, true);
2018-06-19 19:58:52 +00:00
prepDataAndSend ( cmdPayload ) ;
}
2021-03-22 07:11:43 +00:00
QByteArray rigCommander : : makeFreqPayload ( freqt freq )
{
QByteArray result ;
quint64 freqInt = freq . Hz ;
unsigned char a ;
int numchars = 5 ;
for ( int i = 0 ; i < numchars ; i + + ) {
a = 0 ;
a | = ( freqInt ) % 10 ;
freqInt / = 10 ;
a | = ( ( freqInt ) % 10 ) < < 4 ;
freqInt / = 10 ;
result . append ( a ) ;
//printHex(result, false, true);
}
return result ;
}
2018-06-19 19:58:52 +00:00
QByteArray rigCommander : : makeFreqPayload ( double freq )
{
quint64 freqInt = ( quint64 ) ( freq * 1E6 ) ;
QByteArray result ;
unsigned char a ;
int numchars = 5 ;
for ( int i = 0 ; i < numchars ; i + + ) {
a = 0 ;
a | = ( freqInt ) % 10 ;
freqInt / = 10 ;
a | = ( ( freqInt ) % 10 ) < < 4 ;
freqInt / = 10 ;
result . append ( a ) ;
//printHex(result, false, true);
}
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "encoded frequency for " << freq << " as int " << freqInt;
2018-06-19 19:58:52 +00:00
//printHex(result, false, true);
return result ;
}
2021-04-24 07:31:51 +00:00
void rigCommander : : setRitEnable ( bool ritEnabled )
{
QByteArray payload ;
if ( ritEnabled )
{
payload . setRawData ( " \x21 \x01 \x01 " , 3 ) ;
} else {
payload . setRawData ( " \x21 \x01 \x00 " , 3 ) ;
}
prepDataAndSend ( payload ) ;
}
void rigCommander : : getRitEnabled ( )
{
QByteArray payload ;
payload . setRawData ( " \x21 \x01 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getRitValue ( )
{
QByteArray payload ;
payload . setRawData ( " \x21 \x00 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setRitValue ( int ritValue )
{
QByteArray payload ;
QByteArray freqBytes ;
freqt f ;
bool isNegative = false ;
payload . setRawData ( " \x21 \x00 " , 2 ) ;
if ( ritValue < 0 )
{
isNegative = true ;
ritValue * = - 1 ;
}
if ( ritValue > 9999 )
return ;
f . Hz = ritValue ;
freqBytes = makeFreqPayload ( f ) ;
freqBytes . truncate ( 2 ) ;
payload . append ( freqBytes ) ;
payload . append ( QByteArray ( 1 , ( char ) isNegative ) ) ;
prepDataAndSend ( payload ) ;
}
2021-06-26 06:56:19 +00:00
void rigCommander : : setMode ( mode_info m )
{
QByteArray payload ;
if ( rigCaps . model = = model706 )
{
m . filter = ' \x01 ' ;
}
if ( m . mk = = modeWFM )
{
m . filter = ' \x01 ' ;
}
payload . setRawData ( " \x06 " , 1 ) ;
payload . append ( m . reg ) ;
payload . append ( m . filter ) ;
prepDataAndSend ( payload ) ;
}
2021-02-13 18:02:45 +00:00
void rigCommander : : setMode ( unsigned char mode , unsigned char modeFilter )
2018-06-19 19:58:52 +00:00
{
QByteArray payload ;
2021-02-13 18:02:45 +00:00
if ( mode < 0x22 + 1 )
2018-06-19 19:58:52 +00:00
{
2021-02-13 18:02:45 +00:00
// mode command | filter
// 0x01 | Filter 01 automatically
// 0x04 | user-specififed 01, 02, 03 | note, is "read the current mode" on older rigs
// 0x06 | "default" filter is auto
2018-11-07 23:54:03 +00:00
payload . setRawData ( " \x06 " , 1 ) ; // cmd 06 needs filter specified
//payload.setRawData("\x04", 1); // cmd 04 will apply the default filter, but it seems to always pick FIL 02
2018-06-19 19:58:52 +00:00
payload . append ( mode ) ;
2021-02-13 18:02:45 +00:00
if ( rigCaps . model = = model706 )
{
payload . append ( " \x01 " ) ; // "normal" on IC-706
} else {
2021-06-24 19:40:23 +00:00
if ( mode = = 0x06 )
{
payload . append ( 0x01 ) ;
} else {
payload . append ( modeFilter ) ;
}
2021-02-13 18:02:45 +00:00
}
2021-05-07 22:46:47 +00:00
2018-06-19 19:58:52 +00:00
prepDataAndSend ( payload ) ;
}
}
2021-05-09 06:46:44 +00:00
void rigCommander : : setDataMode ( bool dataOn , unsigned char filter )
2018-11-07 23:54:03 +00:00
{
QByteArray payload ;
payload . setRawData ( " \x1A \x06 " , 2 ) ;
if ( dataOn )
{
2021-05-15 02:49:37 +00:00
payload . append ( " \x01 " , 1 ) ; // data mode on
2021-05-09 06:46:44 +00:00
payload . append ( filter ) ;
2018-11-07 23:54:03 +00:00
} else {
payload . append ( " \x00 \x00 " , 2 ) ; // data mode off, bandwidth not defined per ICD.
}
prepDataAndSend ( payload ) ;
}
2018-06-19 19:58:52 +00:00
void rigCommander : : getFrequency ( )
{
// figure out frequency and then respond with haveFrequency();
// send request to radio
// 1. make the data
QByteArray payload ( " \x03 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getMode ( )
{
QByteArray payload ( " \x04 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getDataMode ( )
{
QByteArray payload ( " \x1A \x06 " ) ;
prepDataAndSend ( payload ) ;
}
2021-02-18 07:26:10 +00:00
void rigCommander : : setDuplexMode ( duplexMode dm )
{
2021-02-18 07:41:01 +00:00
QByteArray payload ;
2021-02-19 05:47:19 +00:00
if ( dm = = dmDupAutoOff )
{
payload . setRawData ( " \x1A \x05 \x00 \x46 \x00 " , 5 ) ;
} else if ( dm = = dmDupAutoOn )
{
payload . setRawData ( " \x1A \x05 \x00 \x46 \x01 " , 5 ) ;
} else {
payload . setRawData ( " \x0F " , 1 ) ;
payload . append ( ( unsigned char ) dm ) ;
}
2021-02-18 07:41:01 +00:00
prepDataAndSend ( payload ) ;
2021-02-18 07:26:10 +00:00
}
void rigCommander : : getDuplexMode ( )
{
2021-02-18 07:41:01 +00:00
QByteArray payload ;
2021-02-19 05:47:19 +00:00
// Duplex mode:
payload . setRawData ( " \x0F " , 1 ) ;
2021-02-18 07:41:01 +00:00
prepDataAndSend ( payload ) ;
2021-02-19 05:47:19 +00:00
// Auto Repeater Mode:
payload . setRawData ( " \x1A \x05 \x00 \x46 " , 4 ) ;
2021-02-18 07:41:01 +00:00
prepDataAndSend ( payload ) ;
2021-02-18 07:26:10 +00:00
}
2021-04-04 07:36:21 +00:00
void rigCommander : : getTransmitFrequency ( )
{
QByteArray payload ;
payload . setRawData ( " \x1C \x03 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setTone ( quint16 tone )
{
2021-04-05 06:33:56 +00:00
QByteArray fenc = encodeTone ( tone ) ;
2021-04-04 07:36:21 +00:00
QByteArray payload ;
payload . setRawData ( " \x1B \x00 " , 2 ) ;
payload . append ( fenc ) ;
2021-04-05 06:33:56 +00:00
2021-05-15 17:53:16 +00:00
//qInfo() << __func__ << "TONE encoded payload: ";
2021-04-05 06:33:56 +00:00
printHex ( payload ) ;
prepDataAndSend ( payload ) ;
2021-04-04 07:36:21 +00:00
}
2021-02-18 07:26:10 +00:00
2021-04-04 07:36:21 +00:00
void rigCommander : : setTSQL ( quint16 tsql )
{
2021-04-05 06:33:56 +00:00
QByteArray fenc = encodeTone ( tsql ) ;
2021-02-18 07:41:01 +00:00
2021-04-04 07:36:21 +00:00
QByteArray payload ;
2021-04-05 06:33:56 +00:00
payload . setRawData ( " \x1B \x01 " , 2 ) ;
2021-04-04 07:36:21 +00:00
payload . append ( fenc ) ;
2021-04-05 06:33:56 +00:00
2021-05-15 17:53:16 +00:00
//qInfo() << __func__ << "TSQL encoded payload: ";
2021-04-05 06:33:56 +00:00
printHex ( payload ) ;
prepDataAndSend ( payload ) ;
2021-04-04 07:36:21 +00:00
}
void rigCommander : : setDTCS ( quint16 dcscode , bool tinv , bool rinv )
{
2021-04-05 06:33:56 +00:00
QByteArray denc = encodeTone ( dcscode , tinv , rinv ) ;
2021-04-04 07:36:21 +00:00
QByteArray payload ;
payload . setRawData ( " \x1B \x02 " , 2 ) ;
payload . append ( denc ) ;
2021-04-05 06:33:56 +00:00
2021-05-15 17:53:16 +00:00
//qInfo() << __func__ << "DTCS encoded payload: ";
2021-04-05 06:33:56 +00:00
printHex ( payload ) ;
prepDataAndSend ( payload ) ;
}
QByteArray rigCommander : : encodeTone ( quint16 tone )
{
return encodeTone ( tone , false , false ) ;
}
QByteArray rigCommander : : encodeTone ( quint16 tone , bool tinv , bool rinv )
{
// This function is fine to use for DTCS and TONE
QByteArray enct ;
unsigned char inv = 0 ;
inv = inv | ( unsigned char ) rinv ;
inv = inv | ( ( unsigned char ) tinv ) < < 4 ;
enct . append ( inv ) ;
unsigned char hundreds = tone / 1000 ;
unsigned char tens = ( tone - ( hundreds * 1000 ) ) / 100 ;
unsigned char ones = ( tone - ( hundreds * 1000 ) - ( tens * 100 ) ) / 10 ;
unsigned char dec = ( tone - ( hundreds * 1000 ) - ( tens * 100 ) - ( ones * 10 ) ) ;
enct . append ( tens | ( hundreds < < 4 ) ) ;
enct . append ( dec | ( ones < < 4 ) ) ;
return enct ;
}
quint16 rigCommander : : decodeTone ( QByteArray eTone )
{
bool t ;
bool r ;
return decodeTone ( eTone , t , r ) ;
}
quint16 rigCommander : : decodeTone ( QByteArray eTone , bool & tinv , bool & rinv )
{
// index: 00 01 02 03 04
// CTCSS: 1B 01 00 12 73 = PL 127.3, decode as 1273
// D(T)CS: 1B 01 TR 01 23 = T/R Invert bits + DCS code 123
2021-05-31 23:25:20 +00:00
if ( eTone . length ( ) < 5 ) {
return 0 ;
}
2021-04-05 06:33:56 +00:00
tinv = false ; rinv = false ;
quint16 result = 0 ;
if ( ( eTone . at ( 2 ) & 0x01 ) = = 0x01 )
tinv = true ;
if ( ( eTone . at ( 2 ) & 0x10 ) = = 0x10 )
rinv = true ;
result + = ( eTone . at ( 4 ) & 0x0f ) ;
result + = ( ( eTone . at ( 4 ) & 0xf0 ) > > 4 ) * 10 ;
result + = ( eTone . at ( 3 ) & 0x0f ) * 100 ;
result + = ( ( eTone . at ( 3 ) & 0xf0 ) > > 4 ) * 1000 ;
return result ;
2021-04-04 07:36:21 +00:00
}
void rigCommander : : getTone ( )
{
QByteArray payload ;
payload . setRawData ( " \x1B \x00 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getTSQL ( )
{
QByteArray payload ;
payload . setRawData ( " \x1B \x01 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getDTCS ( )
{
QByteArray payload ;
payload . setRawData ( " \x1B \x02 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getRptAccessMode ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x5D " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setRptAccessMode ( rptAccessTxRx ratr )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x5D " , 2 ) ;
payload . append ( ( unsigned char ) ratr ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setIPP ( bool enabled )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x65 " , 2 ) ;
if ( enabled )
{
payload . append ( " \x01 " ) ;
} else {
payload . append ( " \x00 " ) ;
}
prepDataAndSend ( payload ) ;
}
void rigCommander : : getIPP ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x65 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setSatelliteMode ( bool enabled )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x5A " , 2 ) ;
if ( enabled )
{
payload . append ( " \x01 " ) ;
} else {
payload . append ( " \x00 " ) ;
}
prepDataAndSend ( payload ) ;
}
void rigCommander : : getSatelliteMode ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x5A " , 2 ) ;
prepDataAndSend ( payload ) ;
}
2021-02-18 07:41:01 +00:00
2018-11-07 23:54:03 +00:00
void rigCommander : : getPTT ( )
{
2021-11-07 05:49:10 +00:00
//if(rigCaps.useRTSforPTT && !usingNativeLAN)
//{
// emit havePTTStatus(comm->rtsStatus());
//} else {
2022-01-04 18:34:34 +00:00
QByteArray payload ;
payload . setRawData ( " \x1C \x00 " , 2 ) ;
prepDataAndSend ( payload ) ;
2021-11-07 05:49:10 +00:00
//}
2018-11-07 23:54:03 +00:00
}
2018-11-16 22:08:21 +00:00
void rigCommander : : getBandStackReg ( char band , char regCode )
{
QByteArray payload ( " \x1A \x01 " ) ;
payload . append ( band ) ; // [01 through 11]
payload . append ( regCode ) ; // [01...03]. 01 = latest, 03 = oldest
prepDataAndSend ( payload ) ;
}
2018-11-07 23:54:03 +00:00
void rigCommander : : setPTT ( bool pttOn )
{
//bool pttAllowed = false;
if ( pttAllowed )
{
2021-11-07 05:49:10 +00:00
QByteArray payload ( " \x1C \x00 " , 2 ) ;
payload . append ( ( char ) pttOn ) ;
prepDataAndSend ( payload ) ;
2018-11-07 23:54:03 +00:00
}
}
2018-06-19 19:58:52 +00:00
void rigCommander : : setCIVAddr ( unsigned char civAddr )
{
2021-05-30 22:08:22 +00:00
// Note: This sets the radio's CIV address
2018-11-16 22:08:21 +00:00
// the computer's CIV address is defined in the header file.
2021-05-30 22:08:22 +00:00
2018-06-19 19:58:52 +00:00
this - > civAddr = civAddr ;
2021-05-30 22:08:22 +00:00
payloadPrefix = QByteArray ( " \xFE \xFE " ) ;
payloadPrefix . append ( civAddr ) ;
payloadPrefix . append ( ( char ) compCivAddr ) ;
2018-06-19 19:58:52 +00:00
}
2021-02-28 20:10:07 +00:00
void rigCommander : : handleNewData ( const QByteArray & data )
{
2021-02-18 09:14:41 +00:00
emit haveDataForServer ( data ) ;
2018-06-19 19:58:52 +00:00
parseData ( data ) ;
}
2021-03-01 19:53:12 +00:00
void rigCommander : : receiveAudioData ( const audioPacket & data )
2021-02-28 20:10:07 +00:00
{
emit haveAudioData ( data ) ;
}
2018-06-22 23:31:52 +00:00
void rigCommander : : parseData ( QByteArray dataInput )
2018-06-19 19:58:52 +00:00
{
2018-06-22 23:31:52 +00:00
// TODO: Clean this up.
// It finally works very nicely, needs to be streamlined.
//
2018-06-19 19:58:52 +00:00
2018-06-22 23:31:52 +00:00
int index = 0 ;
volatile int count = 0 ; // debug purposes
2018-06-19 19:58:52 +00:00
2018-06-22 23:31:52 +00:00
// use this:
QList < QByteArray > dataList = dataInput . split ( ' \xFD ' ) ;
QByteArray data ;
2021-05-15 17:53:16 +00:00
// qInfo(logRig()) << "data list has this many elements: " << dataList.size();
2018-06-22 23:31:52 +00:00
if ( dataList . last ( ) . isEmpty ( ) )
{
dataList . removeLast ( ) ; // if the original ended in FD, then there is a blank entry at the end.
}
// Only thing is, each frame is missing '\xFD' at the end. So append! Keeps the frames intact.
for ( index = 0 ; index < dataList . count ( ) ; index + + )
{
data = dataList [ index ] ;
data . append ( ' \xFD ' ) ; // because we expect it to be there.
// foreach(listitem)
// listitem.append('\xFD');
// continue parsing...
2018-06-19 19:58:52 +00:00
2018-06-22 23:31:52 +00:00
count + + ;
// Data echo'd back from the rig start with this:
// fe fe 94 e0 ...... fd
2018-06-19 19:58:52 +00:00
2018-06-22 23:31:52 +00:00
// Data from the rig that is not an echo start with this:
// fe fe e0 94 ...... fd (for example, a reply to a query)
// Data from the rig that was not asked for is sent to controller 0x00:
// fe fe 00 94 ...... fd (for example, user rotates the tune control or changes the mode)
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Data received: ";
2018-06-22 23:31:52 +00:00
//printHex(data, false, true);
if ( data . length ( ) < 4 )
2018-06-19 19:58:52 +00:00
{
2018-06-22 23:31:52 +00:00
if ( data . length ( ) )
{
// Finally this almost never happens
2021-05-15 17:53:16 +00:00
// qInfo(logRig()) << "Data length too short: " << data.length() << " bytes. Data:";
2018-11-29 22:32:59 +00:00
//printHex(data, false, true);
2018-06-22 23:31:52 +00:00
}
// no
//return;
// maybe:
// continue;
2018-06-19 19:58:52 +00:00
}
2018-06-22 23:31:52 +00:00
if ( ! data . startsWith ( " \xFE \xFE " ) )
2018-06-19 19:58:52 +00:00
{
2021-05-15 17:53:16 +00:00
// qInfo(logRig()) << "Warning: Invalid data received, did not start with FE FE.";
2018-06-22 23:31:52 +00:00
// find 94 e0 and shift over,
// or look inside for a second FE FE
// Often a local echo will miss a few bytes at the beginning.
if ( data . startsWith ( ' \xFE ' ) )
{
data . prepend ( ' \xFE ' ) ;
2021-05-15 17:53:16 +00:00
// qInfo(logRig()) << "Warning: Working with prepended data stream.";
2018-06-22 23:31:52 +00:00
parseData ( payloadIn ) ;
return ;
} else {
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Error: Could not reconstruct corrupted data: ";
2018-11-29 21:57:15 +00:00
//printHex(data, false, true);
2018-06-22 23:31:52 +00:00
// data.right(data.length() - data.find('\xFE\xFE'));
// if found do not return and keep going.
return ;
}
2018-06-19 19:58:52 +00:00
}
2018-06-22 23:31:52 +00:00
if ( ( unsigned char ) data [ 02 ] = = civAddr )
{
// data is or begins with an echoback from what we sent
// find the first 'fd' and cut it. Then continue.
//payloadIn = data.right(data.length() - data.indexOf('\xfd')-1);
2021-05-15 17:53:16 +00:00
// qInfo(logRig()) << "[FOUND] Trimmed off echo:";
2018-06-22 23:31:52 +00:00
//printHex(payloadIn, false, true);
//parseData(payloadIn);
//return;
}
2018-06-19 19:58:52 +00:00
2021-02-10 17:32:56 +00:00
incomingCIVAddr = data [ 03 ] ; // track the CIV of the sender.
2018-06-22 23:31:52 +00:00
switch ( data [ 02 ] )
{
// case civAddr: // can't have a variable here :-(
// // data is or begins with an echoback from what we sent
// // find the first 'fd' and cut it. Then continue.
// payloadIn = data.right(data.length() - data.indexOf('\xfd')-1);
2021-05-15 17:53:16 +00:00
// //qInfo(logRig()) << "Trimmed off echo:";
2018-06-22 23:31:52 +00:00
// //printHex(payloadIn, false, true);
// parseData(payloadIn);
// break;
2018-11-16 22:08:21 +00:00
// case '\xE0':
2019-01-10 20:31:04 +00:00
case ( char ) 0xE0 :
2018-11-16 22:08:21 +00:00
case ( char ) compCivAddr :
2018-06-22 23:31:52 +00:00
// data is a reply to some query we sent
// extract the payload out and parse.
// payload = getpayload(data); // or something
// parse (payload); // recursive ok?
payloadIn = data . right ( data . length ( ) - 4 ) ;
2021-06-15 17:28:20 +00:00
if ( payloadIn . contains ( " \xFE " ) )
{
//qDebug(logRig()) << "Corrupted data contains FE within message body: ";
//printHex(payloadIn);
break ;
}
2018-06-22 23:31:52 +00:00
parseCommand ( ) ;
break ;
case ' \x00 ' :
// data send initiated by the rig due to user control
// extract the payload out and parse.
2021-02-10 17:32:56 +00:00
if ( ( unsigned char ) data [ 03 ] = = compCivAddr )
{
// This is an echo of our own broadcast request.
// The data are "to 00" and "from E1"
// Don't use it!
2021-06-15 17:28:20 +00:00
qDebug ( logRig ( ) ) < < " Caught it! Found the echo'd broadcast request from us! Rig has not responded to broadcast query yet. " ;
2021-02-10 17:32:56 +00:00
} else {
2021-06-15 17:28:20 +00:00
payloadIn = data . right ( data . length ( ) - 4 ) ; // Removes FE FE E0 94 part
if ( payloadIn . contains ( " \xFE " ) )
{
//qDebug(logRig()) << "Corrupted data contains FE within message body: ";
//printHex(payloadIn);
break ;
}
2021-02-10 17:32:56 +00:00
parseCommand ( ) ;
}
2018-06-22 23:31:52 +00:00
break ;
default :
// could be for other equipment on the CIV network.
// just drop for now.
2018-11-20 07:42:34 +00:00
// relaySendOutData(data);
2018-06-22 23:31:52 +00:00
break ;
}
}
/*
if ( dataList . length ( ) > 1 )
2018-06-19 19:58:52 +00:00
{
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < " Recovered " < < count < < " frames from single data with size " < < dataList . count ( ) ;
2018-06-19 19:58:52 +00:00
}
2018-06-22 23:31:52 +00:00
*/
2018-06-19 19:58:52 +00:00
}
void rigCommander : : parseCommand ( )
{
// note: data already is trimmed of the beginning FE FE E0 94 stuff.
2021-04-11 07:42:25 +00:00
bool isSpectrumData = payloadIn . startsWith ( QByteArray ( ) . setRawData ( " \x27 \x00 " , 2 ) ) ;
if ( ( ! isSpectrumData ) & & ( payloadIn [ 00 ] ! = ' \x15 ' ) )
2018-11-16 22:08:21 +00:00
{
2021-03-03 06:11:01 +00:00
// We do not log spectrum and meter data,
// as they tend to clog up any useful logging.
printHex ( payloadIn ) ;
2018-11-16 22:08:21 +00:00
}
2018-06-19 19:58:52 +00:00
switch ( payloadIn [ 00 ] )
{
case 00 :
// frequency data
parseFrequency ( ) ;
break ;
case 03 :
parseFrequency ( ) ;
break ;
2019-01-11 00:10:17 +00:00
case ' \x25 ' :
if ( ( int ) payloadIn [ 1 ] = = 0 )
{
2021-03-22 07:11:43 +00:00
emit haveFrequency ( parseFrequency ( payloadIn , 5 ) ) ;
2019-01-11 00:10:17 +00:00
}
break ;
2018-06-19 19:58:52 +00:00
case ' \x01 ' :
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Have mode data";
2018-06-19 19:58:52 +00:00
this - > parseMode ( ) ;
break ;
case ' \x04 ' :
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Have mode data";
2018-06-19 19:58:52 +00:00
this - > parseMode ( ) ;
break ;
2018-12-03 07:16:08 +00:00
case ' \x05 ' :
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Have frequency data";
2020-04-21 03:45:25 +00:00
this - > parseFrequency ( ) ;
2018-12-03 07:16:08 +00:00
break ;
case ' \x06 ' :
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Have mode data";
2018-12-03 07:16:08 +00:00
this - > parseMode ( ) ;
break ;
2021-02-18 07:41:01 +00:00
case ' \x0F ' :
emit haveDuplexMode ( ( duplexMode ) ( unsigned char ) payloadIn [ 1 ] ) ;
2022-01-04 18:34:34 +00:00
state . set ( DUPLEX , ( duplexMode ) ( unsigned char ) payloadIn [ 1 ] , false ) ;
2021-02-18 07:41:01 +00:00
break ;
2021-04-11 05:48:32 +00:00
case ' \x11 ' :
emit haveAttenuator ( ( unsigned char ) payloadIn . at ( 1 ) ) ;
2022-01-04 18:34:34 +00:00
state . set ( ATTENUATOR , ( quint8 ) payloadIn [ 1 ] , false ) ;
2021-04-11 05:48:32 +00:00
break ;
2021-07-16 18:33:15 +00:00
case ' \x12 ' :
emit haveAntenna ( ( unsigned char ) payloadIn . at ( 1 ) , ( bool ) payloadIn . at ( 2 ) ) ;
2022-01-04 18:34:34 +00:00
state . set ( ANTENNA , ( quint8 ) payloadIn [ 1 ] , false ) ;
state . set ( RXANTENNA , ( bool ) payloadIn [ 2 ] , false ) ;
2021-07-16 19:14:59 +00:00
break ;
2018-11-16 22:08:21 +00:00
case ' \x14 ' :
// read levels
parseLevels ( ) ;
break ;
2021-02-15 23:17:48 +00:00
case ' \x15 ' :
// Metering such as s, power, etc
parseLevels ( ) ;
break ;
2021-04-05 06:46:44 +00:00
case ' \x16 ' :
2021-04-11 05:48:32 +00:00
parseRegister16 ( ) ;
2021-04-05 06:46:44 +00:00
break ;
2018-11-20 07:42:34 +00:00
case ' \x19 ' :
2021-05-15 17:53:16 +00:00
// qInfo(logRig()) << "Have rig ID: " << (unsigned int)payloadIn[2];
2018-11-20 07:42:34 +00:00
// printHex(payloadIn, false, true);
2021-02-10 17:32:56 +00:00
model = determineRadioModel ( payloadIn [ 2 ] ) ; // verify this is the model not the CIV
2021-05-20 04:47:14 +00:00
rigCaps . modelID = payloadIn [ 2 ] ;
2021-02-10 17:32:56 +00:00
determineRigCaps ( ) ;
2021-05-20 04:47:14 +00:00
qInfo ( logRig ( ) ) < < " Have rig ID: decimal: " < < ( unsigned int ) rigCaps . modelID ;
2021-02-10 17:32:56 +00:00
2021-04-25 07:23:52 +00:00
break ;
case ' \x21 ' :
// RIT and Delta TX:
parseRegister21 ( ) ;
2018-11-20 07:42:34 +00:00
break ;
2019-01-11 00:10:17 +00:00
case ' \x26 ' :
if ( ( int ) payloadIn [ 1 ] = = 0 )
{
// This works but LSB comes out as CW?
// Also, an opportunity to read the data mode
// payloadIn = payloadIn.right(3);
// this->parseMode();
}
break ;
2018-06-19 19:58:52 +00:00
case ' \x27 ' :
// scope data
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Have scope data";
2018-06-19 19:58:52 +00:00
//printHex(payloadIn, false, true);
2018-12-18 22:34:04 +00:00
parseWFData ( ) ;
//parseSpectrum();
2018-06-19 19:58:52 +00:00
break ;
2018-06-25 07:34:33 +00:00
case ' \x1A ' :
if ( payloadIn [ 01 ] = = ' \x05 ' )
{
parseDetailedRegisters1A05 ( ) ;
} else {
parseRegisters1A ( ) ;
}
2018-11-16 22:08:21 +00:00
break ;
2021-04-05 06:33:56 +00:00
case ' \x1B ' :
parseRegister1B ( ) ;
break ;
2018-11-07 23:54:03 +00:00
case ' \x1C ' :
parseRegisters1C ( ) ;
break ;
2018-06-19 19:58:52 +00:00
case ' \xFB ' :
// Fine Business, ACK from rig.
break ;
case ' \xFA ' :
// error
2021-05-15 17:53:16 +00:00
2021-02-23 21:21:22 +00:00
qDebug ( logRig ( ) ) < < " Error (FA) received from rig. " ;
2018-06-19 19:58:52 +00:00
printHex ( payloadIn , false , true ) ;
break ;
2018-11-07 23:54:03 +00:00
2018-06-19 19:58:52 +00:00
default :
2019-01-10 20:31:04 +00:00
// This gets hit a lot when the pseudo-term is
// using commands wfview doesn't know yet.
2021-05-15 17:53:16 +00:00
// qInfo(logRig()) << "Have other data with cmd: " << std::hex << payloadIn[00];
2019-01-10 20:31:04 +00:00
// printHex(payloadIn, false, true);
2018-06-19 19:58:52 +00:00
break ;
}
2018-06-22 23:31:52 +00:00
// is any payload left?
2018-06-19 19:58:52 +00:00
}
2018-11-16 22:08:21 +00:00
void rigCommander : : parseLevels ( )
{
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Received a level status readout: ";
2018-11-16 22:08:21 +00:00
// printHex(payloadIn, false, true);
2018-11-18 08:01:20 +00:00
// wrong: unsigned char level = (payloadIn[2] * 100) + payloadIn[03];
unsigned char hundreds = payloadIn [ 2 ] ;
unsigned char tens = ( payloadIn [ 3 ] & 0xf0 ) > > 4 ;
unsigned char units = ( payloadIn [ 3 ] & 0x0f ) ;
2021-08-08 16:14:48 +00:00
unsigned char level = ( ( unsigned char ) 100 * hundreds ) + ( 10 * tens ) + units ;
2018-11-18 08:01:20 +00:00
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Level is: " << (int)level << " or " << 100.0*level/255.0 << "%";
2018-11-16 22:08:21 +00:00
// Typical RF gain response (rather low setting):
// "INDEX: 00 01 02 03 04 "
// "DATA: 14 02 00 78 fd "
2021-02-21 04:41:19 +00:00
if ( payloadIn [ 0 ] = = ' \x14 ' )
2018-11-16 22:08:21 +00:00
{
2021-02-15 23:17:48 +00:00
switch ( payloadIn [ 1 ] )
{
case ' \x01 ' :
2021-03-23 18:19:47 +00:00
// AF level - ignore if LAN connection.
if ( udp = = Q_NULLPTR ) {
emit haveAfGain ( level ) ;
2022-01-04 18:34:34 +00:00
state . set ( AFGAIN , level , false ) ;
}
else {
state . set ( AFGAIN , localVolume , false ) ;
2021-03-23 18:19:47 +00:00
}
2021-02-15 23:17:48 +00:00
break ;
case ' \x02 ' :
// RX RF Gain
emit haveRfGain ( level ) ;
2022-01-04 18:34:34 +00:00
state . set ( RFGAIN , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
case ' \x03 ' :
// Squelch level
2022-01-04 18:34:34 +00:00
emit haveSql ( level ) ;
state . set ( SQUELCH , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
2021-11-05 17:09:31 +00:00
case ' \x07 ' :
// Twin BPF Inner, or, IF-Shift level
if ( rigCaps . hasTBPF )
emit haveTPBFInner ( level ) ;
else
emit haveIFShift ( level ) ;
break ;
case ' \x08 ' :
// Twin BPF Outer
emit haveTPBFOuter ( level ) ;
break ;
2021-08-28 23:25:23 +00:00
case ' \x09 ' :
// CW Pitch - ignore for now
break ;
2021-02-15 23:17:48 +00:00
case ' \x0A ' :
// TX RF level
emit haveTxPower ( level ) ;
2022-03-19 19:05:46 +00:00
state . set ( RFPOWER , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
case ' \x0B ' :
// Mic Gain
emit haveMicGain ( level ) ;
2022-01-04 18:34:34 +00:00
state . set ( MICGAIN , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
2021-08-28 23:25:23 +00:00
case ' \x0C ' :
// CW Keying Speed - ignore for now
break ;
case ' \x0D ' :
// Notch filder setting - ignore for now
break ;
2021-02-15 23:17:48 +00:00
case ' \x0E ' :
// compressor level
emit haveCompLevel ( level ) ;
2022-01-04 18:34:34 +00:00
state . set ( COMPLEVEL , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
2021-08-28 23:25:23 +00:00
case ' \x12 ' :
// NB level - ignore for now
break ;
2021-02-15 23:17:48 +00:00
case ' \x15 ' :
// monitor level
emit haveMonitorLevel ( level ) ;
2022-01-04 18:34:34 +00:00
state . set ( MONITORLEVEL , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
case ' \x16 ' :
// VOX gain
emit haveVoxGain ( level ) ;
2022-01-04 18:34:34 +00:00
state . set ( VOXGAIN , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
case ' \x17 ' :
// anti-VOX gain
emit haveAntiVoxGain ( level ) ;
2022-01-04 18:34:34 +00:00
state . set ( ANTIVOXGAIN , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
default :
2021-06-15 17:28:20 +00:00
qInfo ( logRig ( ) ) < < " Unknown control level (0x14) received at register " < < QString ( " 0x%1 " ) . arg ( ( int ) payloadIn [ 1 ] , 2 , 16 ) < < " with level " < < QString ( " 0x%1 " ) . arg ( ( int ) level , 2 , 16 ) < < " , int= " < < ( int ) level ;
printHex ( payloadIn ) ;
2021-02-15 23:17:48 +00:00
break ;
}
return ;
}
2021-02-21 04:41:19 +00:00
if ( payloadIn [ 0 ] = = ' \x15 ' )
2021-02-15 23:17:48 +00:00
{
switch ( payloadIn [ 1 ] )
{
2022-04-20 12:35:23 +00:00
case ' \x01 ' :
// noise or s-meter sequelch status
break ;
2021-02-15 23:17:48 +00:00
case ' \x02 ' :
// S-Meter
2021-02-21 04:41:19 +00:00
emit haveMeter ( meterS , level ) ;
2022-01-04 18:34:34 +00:00
state . set ( SMETER , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
2021-07-18 21:27:21 +00:00
case ' \x04 ' :
// Center (IC-R8600)
emit haveMeter ( meterCenter , level ) ;
2022-01-04 18:34:34 +00:00
state . set ( SMETER , level , false ) ;
2021-07-18 21:27:21 +00:00
break ;
2022-04-20 12:35:23 +00:00
case ' \x05 ' :
// Various squelch (tone etc.)
break ;
2021-02-15 23:17:48 +00:00
case ' \x11 ' :
// RF-Power meter
2021-02-21 04:41:19 +00:00
emit haveMeter ( meterPower , level ) ;
2022-01-04 18:34:34 +00:00
state . set ( POWERMETER , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
case ' \x12 ' :
// SWR
2021-02-21 04:41:19 +00:00
emit haveMeter ( meterSWR , level ) ;
2022-01-04 18:34:34 +00:00
state . set ( SWRMETER , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
case ' \x13 ' :
// ALC
2021-02-21 04:41:19 +00:00
emit haveMeter ( meterALC , level ) ;
2022-01-04 18:34:34 +00:00
state . set ( ALCMETER , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
case ' \x14 ' :
// COMP dB reduction
2021-02-21 04:41:19 +00:00
emit haveMeter ( meterComp , level ) ;
2022-01-04 18:34:34 +00:00
state . set ( COMPMETER , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
case ' \x15 ' :
// VD (12V)
2021-02-21 04:41:19 +00:00
emit haveMeter ( meterVoltage , level ) ;
2022-01-04 18:34:34 +00:00
state . set ( VOLTAGEMETER , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
case ' \x16 ' :
// ID
2021-02-21 04:41:19 +00:00
emit haveMeter ( meterCurrent , level ) ;
2022-01-04 18:34:34 +00:00
state . set ( CURRENTMETER , level , false ) ;
2021-02-15 23:17:48 +00:00
break ;
default :
2021-05-15 22:36:57 +00:00
qInfo ( logRig ( ) ) < < " Unknown meter level (0x15) received at register " < < ( unsigned int ) payloadIn [ 1 ] < < " with level " < < level ;
2021-02-15 23:17:48 +00:00
break ;
}
return ;
2018-11-16 22:08:21 +00:00
}
2021-02-15 23:17:48 +00:00
2018-11-16 22:08:21 +00:00
}
2021-11-05 17:09:31 +00:00
void rigCommander : : setIFShift ( unsigned char level )
{
QByteArray payload ( " \x14 \x07 " ) ;
payload . append ( bcdEncodeInt ( level ) ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setTPBFInner ( unsigned char level )
{
QByteArray payload ( " \x14 \x07 " ) ;
payload . append ( bcdEncodeInt ( level ) ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setTPBFOuter ( unsigned char level )
{
QByteArray payload ( " \x14 \x08 " ) ;
payload . append ( bcdEncodeInt ( level ) ) ;
prepDataAndSend ( payload ) ;
}
2021-02-16 04:32:14 +00:00
void rigCommander : : setTxPower ( unsigned char power )
{
QByteArray payload ( " \x14 \x0A " ) ;
payload . append ( bcdEncodeInt ( power ) ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setMicGain ( unsigned char gain )
{
QByteArray payload ( " \x14 \x0B " ) ;
payload . append ( bcdEncodeInt ( gain ) ) ;
prepDataAndSend ( payload ) ;
}
2021-02-18 07:26:10 +00:00
void rigCommander : : getModInput ( bool dataOn )
2021-02-17 08:00:28 +00:00
{
2021-02-18 07:26:10 +00:00
setModInput ( inputMic , dataOn , true ) ;
}
void rigCommander : : setModInput ( rigInput input , bool dataOn )
{
setModInput ( input , dataOn , false ) ;
}
void rigCommander : : setModInput ( rigInput input , bool dataOn , bool isQuery )
{
// The input enum is as follows:
// inputMic=0,
// inputACC=1,
// inputUSB=3,
// inputLAN=5,
// inputACCA,
// inputACCB};
2021-02-17 08:00:28 +00:00
QByteArray payload ;
QByteArray inAsByte ;
2021-02-18 07:26:10 +00:00
if ( isQuery )
input = inputMic ;
2021-02-17 08:00:28 +00:00
switch ( rigCaps . model )
{
case model9700 :
payload . setRawData ( " \x1A \x05 \x01 \x15 " , 4 ) ;
payload . append ( ( unsigned char ) input ) ;
break ;
case model7610 :
payload . setRawData ( " \x1A \x05 \x00 \x91 " , 4 ) ;
payload . append ( ( unsigned char ) input ) ;
break ;
case model7300 :
2021-02-18 07:26:10 +00:00
payload . setRawData ( " \x1A \x05 \x00 \x66 " , 4 ) ;
2021-02-17 08:00:28 +00:00
payload . append ( ( unsigned char ) input ) ;
break ;
case model7850 :
payload . setRawData ( " \x1A \x05 \x00 \x63 " , 4 ) ;
switch ( input )
{
case inputMic :
inAsByte . setRawData ( " \x00 " , 1 ) ;
break ;
case inputACCA :
inAsByte . setRawData ( " \x01 " , 1 ) ;
break ;
case inputACCB :
inAsByte . setRawData ( " \x02 " , 1 ) ;
break ;
case inputUSB :
inAsByte . setRawData ( " \x08 " , 1 ) ;
break ;
case inputLAN :
inAsByte . setRawData ( " \x09 " , 1 ) ;
break ;
default :
return ;
}
payload . append ( inAsByte ) ;
break ;
case model705 :
payload . setRawData ( " \x1A \x05 \x01 \x18 " , 4 ) ;
switch ( input )
{
case inputMic :
inAsByte . setRawData ( " \x00 " , 1 ) ;
break ;
case inputUSB :
inAsByte . setRawData ( " \x01 " , 1 ) ;
break ;
case inputLAN : // WLAN
inAsByte . setRawData ( " \x03 " , 1 ) ;
break ;
default :
return ;
}
payload . append ( inAsByte ) ;
break ;
2021-02-18 07:26:10 +00:00
case model7700 :
payload . setRawData ( " \x1A \x05 \x00 \x32 " , 4 ) ;
if ( input = = inputLAN )
{
// NOTE: CIV manual says data may range from 0 to 3
// But data 0x04 does correspond to LAN.
payload . append ( " \x04 " ) ;
} else {
payload . append ( ( unsigned char ) input ) ;
}
break ;
case model7600 :
payload . setRawData ( " \x1A \x05 \x00 \x30 " , 4 ) ;
payload . append ( ( unsigned char ) input ) ;
break ;
case model7100 :
payload . setRawData ( " \x1A \x05 \x00 \x90 " , 4 ) ;
payload . append ( ( unsigned char ) input ) ;
break ;
2021-05-16 07:07:24 +00:00
case model7200 :
payload . setRawData ( " \x1A \x03 \x23 " , 3 ) ;
switch ( input )
{
case inputMic :
payload . setRawData ( " \x00 " , 1 ) ;
break ;
case inputUSB :
payload . setRawData ( " \x03 " , 1 ) ;
break ;
case inputACC :
payload . setRawData ( " \x01 " , 1 ) ;
break ;
default :
return ;
}
2021-02-17 08:00:28 +00:00
default :
break ;
}
2021-02-18 07:26:10 +00:00
if ( dataOn )
{
2021-05-16 07:07:24 +00:00
if ( rigCaps . model = = model7200 )
{
payload [ 2 ] = payload [ 2 ] + 1 ;
} else {
payload [ 3 ] = payload [ 3 ] + 1 ;
}
2021-02-18 07:26:10 +00:00
}
2021-02-17 08:00:28 +00:00
2021-02-18 07:26:10 +00:00
if ( isQuery )
{
payload . truncate ( 4 ) ;
}
2021-02-17 08:00:28 +00:00
2021-02-18 07:26:10 +00:00
prepDataAndSend ( payload ) ;
2021-02-17 08:00:28 +00:00
}
2021-02-20 08:05:23 +00:00
void rigCommander : : setModInputLevel ( rigInput input , unsigned char level )
{
switch ( input )
{
case inputMic :
setMicGain ( level ) ;
break ;
case inputACCA :
setACCGain ( level , 0 ) ;
break ;
case inputACCB :
setACCGain ( level , 1 ) ;
break ;
case inputACC :
setACCGain ( level ) ;
break ;
case inputUSB :
setUSBGain ( level ) ;
break ;
case inputLAN :
setLANGain ( level ) ;
break ;
default :
break ;
}
}
2022-01-04 18:34:34 +00:00
void rigCommander : : setAfMute ( bool gainOn )
{
QByteArray payload ( " \x1a \x09 " ) ;
payload . append ( ( quint8 ) gainOn ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setDialLock ( bool lockOn )
{
QByteArray payload ( " \x16 \x50 " ) ;
payload . append ( ( quint8 ) lockOn ) ;
prepDataAndSend ( payload ) ;
}
2021-02-20 08:05:23 +00:00
void rigCommander : : getModInputLevel ( rigInput input )
{
switch ( input )
{
case inputMic :
getMicGain ( ) ;
break ;
case inputACCA :
getACCGain ( 0 ) ;
break ;
case inputACCB :
getACCGain ( 1 ) ;
break ;
case inputACC :
getACCGain ( ) ;
break ;
case inputUSB :
getUSBGain ( ) ;
break ;
case inputLAN :
getLANGain ( ) ;
break ;
default :
break ;
}
}
2022-01-04 18:34:34 +00:00
void rigCommander : : getAfMute ( )
{
QByteArray payload ( " \x1a \x09 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getDialLock ( )
{
QByteArray payload ( " \x16 \x50 " ) ;
prepDataAndSend ( payload ) ;
}
2021-02-17 08:00:28 +00:00
QByteArray rigCommander : : getUSBAddr ( )
2021-02-16 07:52:14 +00:00
{
QByteArray payload ;
switch ( rigCaps . model )
{
2021-02-17 08:00:28 +00:00
case model705 :
payload . setRawData ( " \x1A \x05 \x01 \x16 " , 4 ) ;
break ;
2021-02-16 07:52:14 +00:00
case model9700 :
payload . setRawData ( " \x1A \x05 \x01 \x13 " , 4 ) ;
break ;
2021-05-16 07:07:24 +00:00
case model7200 :
payload . setRawData ( " \x1A \x03 \x25 " , 3 ) ;
break ;
2021-02-16 07:52:14 +00:00
case model7100 :
case model7610 :
payload . setRawData ( " \x1A \x05 \x00 \x89 " , 4 ) ;
break ;
case model7300 :
payload . setRawData ( " \x1A \x05 \x00 \x65 " , 4 ) ;
break ;
case model7850 :
payload . setRawData ( " \x1A \x05 \x00 \x61 " , 4 ) ;
break ;
case model7600 :
payload . setRawData ( " \x1A \x05 \x00 \x29 " , 4 ) ;
break ;
default :
2021-02-17 08:00:28 +00:00
break ;
2021-02-16 07:52:14 +00:00
}
2021-02-17 08:00:28 +00:00
return payload ;
}
2021-02-18 07:26:10 +00:00
void rigCommander : : getUSBGain ( )
{
QByteArray payload = getUSBAddr ( ) ;
prepDataAndSend ( payload ) ;
}
2021-02-17 08:00:28 +00:00
void rigCommander : : setUSBGain ( unsigned char gain )
{
QByteArray payload = getUSBAddr ( ) ;
2021-02-16 07:52:14 +00:00
payload . append ( bcdEncodeInt ( gain ) ) ;
prepDataAndSend ( payload ) ;
}
2021-02-17 08:00:28 +00:00
QByteArray rigCommander : : getLANAddr ( )
2021-02-16 07:52:14 +00:00
{
2021-02-17 08:00:28 +00:00
QByteArray payload ;
switch ( rigCaps . model )
{
case model705 :
payload . setRawData ( " \x1A \x05 \x01 \x17 " , 4 ) ;
break ;
case model9700 :
payload . setRawData ( " \x1A \x05 \x01 \x14 " , 4 ) ;
break ;
case model7610 :
payload . setRawData ( " \x1A \x05 \x00 \x90 " , 4 ) ;
break ;
case model7850 :
payload . setRawData ( " \x1A \x05 \x00 \x62 " , 4 ) ;
break ;
2021-05-31 21:01:13 +00:00
case model7700 :
payload . setRawData ( " \x1A \x05 \x01 \x92 " , 4 ) ;
break ;
2021-02-17 08:00:28 +00:00
default :
break ;
}
return payload ;
}
2021-02-16 07:52:14 +00:00
2021-02-18 07:26:10 +00:00
void rigCommander : : getLANGain ( )
{
QByteArray payload = getLANAddr ( ) ;
prepDataAndSend ( payload ) ;
}
2021-02-16 07:52:14 +00:00
2021-02-17 08:00:28 +00:00
void rigCommander : : setLANGain ( unsigned char gain )
{
QByteArray payload = getLANAddr ( ) ;
2021-02-16 07:52:14 +00:00
payload . append ( bcdEncodeInt ( gain ) ) ;
prepDataAndSend ( payload ) ;
}
2021-02-20 08:05:23 +00:00
QByteArray rigCommander : : getACCAddr ( unsigned char ab )
2021-02-17 08:00:28 +00:00
{
QByteArray payload ;
// Note: the manual for the IC-7600 does not call out a
// register to adjust the ACC gain.
2021-02-20 08:05:23 +00:00
// 7850: ACC-A = 0, ACC-B = 1
2021-02-17 08:00:28 +00:00
switch ( rigCaps . model )
{
case model9700 :
payload . setRawData ( " \x1A \x05 \x01 \x12 " , 4 ) ;
break ;
case model7100 :
payload . setRawData ( " \x1A \x05 \x00 \x87 " , 4 ) ;
break ;
case model7610 :
payload . setRawData ( " \x1A \x05 \x00 \x88 " , 4 ) ;
break ;
case model7300 :
payload . setRawData ( " \x1A \x05 \x00 \x64 " , 4 ) ;
break ;
case model7850 :
// Note: 0x58 = ACC-A, 0x59 = ACC-B
2021-02-20 08:05:23 +00:00
if ( ab = = 0 )
{
// A
payload . setRawData ( " \x1A \x05 \x00 \x58 " , 4 ) ;
} else {
// B
payload . setRawData ( " \x1A \x05 \x00 \x59 " , 4 ) ;
}
2021-02-17 08:00:28 +00:00
break ;
2021-05-31 21:01:13 +00:00
case model7700 :
payload . setRawData ( " \x1A \x05 \x00 \x30 " , 4 ) ;
break ;
2021-02-17 08:00:28 +00:00
default :
break ;
}
return payload ;
}
2021-02-18 07:26:10 +00:00
void rigCommander : : getACCGain ( )
{
2021-02-20 08:05:23 +00:00
QByteArray payload = getACCAddr ( 0 ) ;
2021-02-18 07:26:10 +00:00
prepDataAndSend ( payload ) ;
}
2021-02-20 08:05:23 +00:00
void rigCommander : : getACCGain ( unsigned char ab )
{
QByteArray payload = getACCAddr ( ab ) ;
prepDataAndSend ( payload ) ;
}
2021-02-16 07:52:14 +00:00
void rigCommander : : setACCGain ( unsigned char gain )
{
2021-02-20 08:05:23 +00:00
QByteArray payload = getACCAddr ( 0 ) ;
payload . append ( bcdEncodeInt ( gain ) ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setACCGain ( unsigned char gain , unsigned char ab )
{
QByteArray payload = getACCAddr ( ab ) ;
2021-02-16 07:52:14 +00:00
payload . append ( bcdEncodeInt ( gain ) ) ;
prepDataAndSend ( payload ) ;
}
2021-02-16 04:32:14 +00:00
void rigCommander : : setCompLevel ( unsigned char compLevel )
{
QByteArray payload ( " \x14 \x0E " ) ;
payload . append ( bcdEncodeInt ( compLevel ) ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setMonitorLevel ( unsigned char monitorLevel )
{
QByteArray payload ( " \x14 \x0E " ) ;
payload . append ( bcdEncodeInt ( monitorLevel ) ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setVoxGain ( unsigned char gain )
{
QByteArray payload ( " \x14 \x16 " ) ;
payload . append ( bcdEncodeInt ( gain ) ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setAntiVoxGain ( unsigned char gain )
{
QByteArray payload ( " \x14 \x17 " ) ;
payload . append ( bcdEncodeInt ( gain ) ) ;
prepDataAndSend ( payload ) ;
}
2018-11-16 22:08:21 +00:00
void rigCommander : : getRfGain ( )
{
QByteArray payload ( " \x14 \x02 " ) ;
prepDataAndSend ( payload ) ;
}
2018-11-17 06:19:44 +00:00
void rigCommander : : getAfGain ( )
{
QByteArray payload ( " \x14 \x01 " ) ;
prepDataAndSend ( payload ) ;
}
2021-11-05 17:09:31 +00:00
void rigCommander : : getIFShift ( )
{
QByteArray payload ( " \x14 \x07 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getTPBFInner ( )
{
QByteArray payload ( " \x14 \x07 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getTPBFOuter ( )
{
QByteArray payload ( " \x14 \x08 " ) ;
prepDataAndSend ( payload ) ;
}
2018-11-18 08:01:20 +00:00
void rigCommander : : getSql ( )
{
QByteArray payload ( " \x14 \x03 " ) ;
prepDataAndSend ( payload ) ;
}
2021-02-15 23:17:48 +00:00
void rigCommander : : getTxLevel ( )
{
QByteArray payload ( " \x14 \x0A " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getMicGain ( )
{
QByteArray payload ( " \x14 \x0B " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getCompLevel ( )
{
QByteArray payload ( " \x14 \x0E " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getMonitorLevel ( )
{
QByteArray payload ( " \x14 \x15 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getVoxGain ( )
{
QByteArray payload ( " \x14 \x16 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getAntiVoxGain ( )
{
QByteArray payload ( " \x14 \x17 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getLevels ( )
{
// Function to grab all levels
2021-02-16 01:15:28 +00:00
getRfGain ( ) ; //0x02
getAfGain ( ) ; // 0x01
getSql ( ) ; // 0x03
getTxLevel ( ) ; // 0x0A
getMicGain ( ) ; // 0x0B
getCompLevel ( ) ; // 0x0E
// getMonitorLevel(); // 0x15
// getVoxGain(); // 0x16
// getAntiVoxGain(); // 0x17
2021-02-15 23:17:48 +00:00
}
2021-02-26 07:57:37 +00:00
void rigCommander : : getMeters ( meterKind meter )
2021-02-15 23:17:48 +00:00
{
2021-02-26 07:57:37 +00:00
switch ( meter )
2021-02-15 23:17:48 +00:00
{
2021-02-26 07:57:37 +00:00
case meterS :
getSMeter ( ) ;
break ;
2021-07-18 21:27:21 +00:00
case meterCenter :
getCenterMeter ( ) ;
break ;
2021-02-26 07:57:37 +00:00
case meterSWR :
getSWRMeter ( ) ;
break ;
case meterPower :
getRFPowerMeter ( ) ;
break ;
case meterALC :
getALCMeter ( ) ;
break ;
case meterComp :
getCompReductionMeter ( ) ;
break ;
case meterVoltage :
getVdMeter ( ) ;
break ;
case meterCurrent :
getIDMeter ( ) ;
break ;
default :
break ;
2021-02-15 23:17:48 +00:00
}
}
void rigCommander : : getSMeter ( )
{
QByteArray payload ( " \x15 \x02 " ) ;
prepDataAndSend ( payload ) ;
}
2021-07-18 21:27:21 +00:00
void rigCommander : : getCenterMeter ( )
{
QByteArray payload ( " \x15 \x04 " ) ;
prepDataAndSend ( payload ) ;
}
2021-02-15 23:17:48 +00:00
void rigCommander : : getRFPowerMeter ( )
{
QByteArray payload ( " \x15 \x11 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getSWRMeter ( )
{
QByteArray payload ( " \x15 \x12 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getALCMeter ( )
{
QByteArray payload ( " \x15 \x13 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getCompReductionMeter ( )
{
QByteArray payload ( " \x15 \x14 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getVdMeter ( )
{
QByteArray payload ( " \x15 \x15 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getIDMeter ( )
{
QByteArray payload ( " \x15 \x16 " ) ;
prepDataAndSend ( payload ) ;
}
2021-02-11 05:22:38 +00:00
void rigCommander : : setSquelch ( unsigned char level )
{
sendLevelCmd ( 0x03 , level ) ;
}
2018-11-17 06:19:44 +00:00
void rigCommander : : setRfGain ( unsigned char level )
{
sendLevelCmd ( 0x02 , level ) ;
}
void rigCommander : : setAfGain ( unsigned char level )
{
2021-03-22 18:53:34 +00:00
if ( udp = = Q_NULLPTR ) {
sendLevelCmd ( 0x01 , level ) ;
}
else {
emit haveSetVolume ( level ) ;
2022-01-04 18:34:34 +00:00
localVolume = level ;
2021-03-22 18:53:34 +00:00
}
2018-11-17 06:19:44 +00:00
}
2021-02-11 08:33:25 +00:00
void rigCommander : : setRefAdjustCourse ( unsigned char level )
{
// 1A 05 00 72 0000-0255
QByteArray payload ;
payload . setRawData ( " \x1A \x05 \x00 \x72 " , 4 ) ;
payload . append ( bcdEncodeInt ( ( unsigned int ) level ) ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setRefAdjustFine ( unsigned char level )
{
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < __FUNCTION__ < < " level: " < < level ;
2021-02-11 08:33:25 +00:00
// 1A 05 00 73 0000-0255
QByteArray payload ;
payload . setRawData ( " \x1A \x05 \x00 \x73 " , 4 ) ;
payload . append ( bcdEncodeInt ( ( unsigned int ) level ) ) ;
prepDataAndSend ( payload ) ;
}
2021-07-09 19:02:50 +00:00
void rigCommander : : setTime ( timekind t )
{
QByteArray payload ;
switch ( rigCaps . model )
{
case model705 :
payload . setRawData ( " \x1A \x05 \x01 \x66 " , 4 ) ;
break ;
case model7300 :
payload . setRawData ( " \x1A \x05 \x00 \x95 " , 4 ) ;
break ;
case model7610 :
payload . setRawData ( " \x1A \x05 \x01 \x59 " , 4 ) ;
break ;
case model7700 :
payload . setRawData ( " \x1A \x05 \x00 \x59 " , 4 ) ;
break ;
case model7850 :
payload . setRawData ( " \x1A \x05 \x00 \x96 " , 4 ) ;
break ;
case model9700 :
payload . setRawData ( " \x1A \x05 \x01 \x80 " , 4 ) ;
break ;
case modelR8600 :
payload . setRawData ( " \x1A \x05 \x01 \x32 " , 4 ) ;
break ;
default :
return ;
break ;
}
payload . append ( convertNumberToHex ( t . hours ) ) ;
payload . append ( convertNumberToHex ( t . minutes ) ) ;
//qDebug(logRig()) << "Setting time to this: ";
//printHex(payload);
prepDataAndSend ( payload ) ;
}
void rigCommander : : setDate ( datekind d )
{
QByteArray payload ;
switch ( rigCaps . model )
{
case model705 :
payload . setRawData ( " \x1A \x05 \x01 \x65 " , 4 ) ;
break ;
case model7300 :
payload . setRawData ( " \x1A \x05 \x00 \x94 " , 4 ) ;
break ;
case model7610 :
payload . setRawData ( " \x1A \x05 \x01 \x58 " , 4 ) ;
break ;
case model7700 :
payload . setRawData ( " \x1A \x05 \x00 \x58 " , 4 ) ;
break ;
case model7850 :
payload . setRawData ( " \x1A \x05 \x00 \x95 " , 4 ) ;
break ;
case model9700 :
payload . setRawData ( " \x1A \x05 \x01 \x79 " , 4 ) ;
break ;
case modelR8600 :
payload . setRawData ( " \x1A \x05 \x01 \x31 " , 4 ) ;
break ;
default :
return ;
break ;
}
// YYYYMMDD
payload . append ( convertNumberToHex ( d . year / 100 ) ) ; // 20
payload . append ( convertNumberToHex ( d . year - 100 * ( d . year / 100 ) ) ) ; // 21
payload . append ( convertNumberToHex ( d . month ) ) ;
payload . append ( convertNumberToHex ( d . day ) ) ;
//qDebug(logRig()) << "Setting date to this: ";
//printHex(payload);
prepDataAndSend ( payload ) ;
}
void rigCommander : : setUTCOffset ( timekind t )
{
QByteArray payload ;
switch ( rigCaps . model )
{
case model705 :
payload . setRawData ( " \x1A \x05 \x01 \x70 " , 4 ) ;
break ;
case model7300 :
payload . setRawData ( " \x1A \x05 \x00 \x96 " , 4 ) ;
break ;
case model7610 :
payload . setRawData ( " \x1A \x05 \x01 \x62 " , 4 ) ;
break ;
case model7700 :
payload . setRawData ( " \x1A \x05 \x00 \x61 " , 4 ) ;
break ;
case model7850 :
// Clock 1:
payload . setRawData ( " \x1A \x05 \x00 \x99 " , 4 ) ;
break ;
case model9700 :
payload . setRawData ( " \x1A \x05 \x01 \x84 " , 4 ) ;
break ;
case modelR8600 :
payload . setRawData ( " \x1A \x05 \x01 \x35 " , 4 ) ;
break ;
default :
return ;
break ;
}
payload . append ( convertNumberToHex ( t . hours ) ) ;
payload . append ( convertNumberToHex ( t . minutes ) ) ;
payload . append ( ( unsigned char ) t . isMinus ) ;
//qDebug(logRig()) << "Setting UTC Offset to this: ";
//printHex(payload);
prepDataAndSend ( payload ) ;
}
unsigned char rigCommander : : convertNumberToHex ( unsigned char num )
{
// Two digit only
if ( num > 99 )
{
qInfo ( logRig ( ) ) < < " Invalid numeric conversion from num " < < num < < " to hex. " ;
return 0xFA ;
}
unsigned char result = 0 ;
result = ( num / 10 ) < < 4 ;
result | = ( num - 10 * ( num / 10 ) ) ;
qDebug ( logRig ( ) ) < < " Converting number: " < < num < < " to hex: " + QString ( " 0x%1 " ) . arg ( result , 2 , 16 , QChar ( ' 0 ' ) ) ;
return result ;
}
2018-11-17 06:19:44 +00:00
void rigCommander : : sendLevelCmd ( unsigned char levAddr , unsigned char level )
{
QByteArray payload ( " \x14 " ) ;
payload . append ( levAddr ) ;
// careful here. The value in the units and tens can't exceed 99.
// ie, can't do this: 01 f2
payload . append ( ( int ) level / 100 ) ; // make sure it works with a zero
// convert the tens:
int tens = ( level - 100 * ( ( int ) level / 100 ) ) / 10 ;
// convert the units:
int units = level - 100 * ( ( int ) level / 100 ) ;
units = units - 10 * ( ( int ) ( units / 10 ) ) ;
// combine and send:
payload . append ( ( tens < < 4 ) | ( units ) ) ; // make sure it works with a zero
prepDataAndSend ( payload ) ;
}
2021-02-11 08:33:25 +00:00
void rigCommander : : getRefAdjustCourse ( )
{
// 1A 05 00 72
QByteArray payload ;
payload . setRawData ( " \x1A \x05 \x00 \x72 " , 4 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getRefAdjustFine ( )
{
// 1A 05 00 73
QByteArray payload ;
payload . setRawData ( " \x1A \x05 \x00 \x73 " , 4 ) ;
prepDataAndSend ( payload ) ;
}
2018-11-07 23:54:03 +00:00
void rigCommander : : parseRegisters1C ( )
{
// PTT lives here
2018-11-17 07:13:59 +00:00
// Not sure if 02 is the right place to switch.
// TODO: test this function
2018-12-20 18:56:54 +00:00
switch ( payloadIn [ 01 ] )
2018-11-07 23:54:03 +00:00
{
case ' \x00 ' :
parsePTT ( ) ;
break ;
2018-11-17 07:13:59 +00:00
case ' \x01 ' :
2018-12-20 19:22:52 +00:00
// ATU status (on/off/tuning)
2018-11-17 07:13:59 +00:00
parseATU ( ) ;
break ;
2018-11-07 23:54:03 +00:00
default :
break ;
}
}
2021-04-25 07:23:52 +00:00
void rigCommander : : parseRegister21 ( )
{
// Register 21 is RIT and Delta TX
int ritHz = 0 ;
freqt f ;
QByteArray longfreq ;
// Example RIT value reply:
// Index: 00 01 02 03 04 05
// DATA: 21 00 32 03 00 fd
switch ( payloadIn [ 01 ] )
{
case ' \x00 ' :
// RIT frequency
//
longfreq = payloadIn . mid ( 2 , 2 ) ;
longfreq . append ( QByteArray ( 3 , ' \x00 ' ) ) ;
f = parseFrequency ( longfreq , 3 ) ;
2021-11-07 05:49:10 +00:00
if ( payloadIn . length ( ) < 5 )
break ;
2021-04-25 07:23:52 +00:00
ritHz = f . Hz * ( ( payloadIn . at ( 4 ) = = ' \x01 ' ) ? - 1 : 1 ) ;
emit haveRitFrequency ( ritHz ) ;
2022-01-04 18:34:34 +00:00
state . set ( RITVALUE , ritHz , false ) ;
2021-04-25 07:23:52 +00:00
break ;
case ' \x01 ' :
// RIT on/off
if ( payloadIn . at ( 02 ) = = ' \x01 ' )
{
emit haveRitEnabled ( true ) ;
} else {
emit haveRitEnabled ( false ) ;
}
2022-01-04 18:34:34 +00:00
state . set ( RITFUNC , ( bool ) payloadIn . at ( 02 ) , false ) ;
2021-04-25 07:23:52 +00:00
break ;
case ' \x02 ' :
// Delta TX setting on/off
break ;
default :
break ;
}
}
2018-11-17 07:13:59 +00:00
void rigCommander : : parseATU ( )
{
2021-05-15 17:53:16 +00:00
// qInfo(logRig()) << "Have ATU status from radio. Emitting.";
2018-12-19 20:31:44 +00:00
// Expect:
2018-12-20 18:56:54 +00:00
// [0]: 0x1c
// [1]: 0x01
// [2]: 0 = off, 0x01 = on, 0x02 = tuning in-progress
emit haveATUStatus ( ( unsigned char ) payloadIn [ 2 ] ) ;
2022-01-04 18:34:34 +00:00
// This is a bool so any non-zero will mean enabled.
state . set ( TUNERFUNC , ( bool ) payloadIn [ 2 ] , false ) ;
2018-11-17 07:13:59 +00:00
}
2018-11-07 23:54:03 +00:00
void rigCommander : : parsePTT ( )
{
// read after payloadIn[02]
2019-01-11 00:10:17 +00:00
if ( payloadIn [ 2 ] = = ( char ) 0 )
2018-11-07 23:54:03 +00:00
{
// PTT off
emit havePTTStatus ( false ) ;
} else {
// PTT on
emit havePTTStatus ( true ) ;
}
2022-01-04 18:34:34 +00:00
state . set ( PTT , ( bool ) payloadIn [ 2 ] , false ) ;
2018-11-07 23:54:03 +00:00
}
2018-06-25 07:34:33 +00:00
void rigCommander : : parseRegisters1A ( )
{
// The simpler of the 1A stuff:
// 1A 06: data mode on/off
// 07: IP+ enable/disable
// 00: memory contents
// 01: band stacking memory contents (last freq used is stored here per-band)
// 03: filter width
// 04: AGC rate
2021-05-15 17:53:16 +00:00
// qInfo(logRig()) << "Looking at register 1A :";
2018-11-18 08:01:20 +00:00
// printHex(payloadIn, false, true);
2018-11-16 22:08:21 +00:00
// "INDEX: 00 01 02 03 04 "
// "DATA: 1a 06 01 03 fd " (data mode enabled, filter width 3 selected)
switch ( payloadIn [ 01 ] )
2018-06-25 07:34:33 +00:00
{
2018-11-16 22:08:21 +00:00
case ' \x00 ' :
// Memory contents
break ;
case ' \x01 ' :
// band stacking register
parseBandStackReg ( ) ;
break ;
2022-01-04 18:34:34 +00:00
case ' \x04 ' :
state . set ( AGC , ( quint8 ) payloadIn [ 2 ] , false ) ;
break ;
2018-06-25 07:34:33 +00:00
case ' \x06 ' :
// data mode
// emit havedataMode( (bool) payloadIn[somebit])
// index
// 03 04
// XX YY
// XX = 00 (off) or 01 (on)
// YY: filter selected, 01 through 03.;
// if YY is 00 then XX was also set to 00
emit haveDataMode ( ( bool ) payloadIn [ 03 ] ) ;
2022-01-04 18:34:34 +00:00
state . set ( DATAMODE , ( quint8 ) payloadIn [ 3 ] , false ) ;
2018-06-25 07:34:33 +00:00
break ;
case ' \x07 ' :
2018-11-16 22:08:21 +00:00
// IP+ status
2018-06-25 07:34:33 +00:00
break ;
2022-01-04 18:34:34 +00:00
case ' \x09 ' :
state . set ( MUTEFUNC , ( quint8 ) payloadIn [ 2 ] , false ) ;
2018-06-25 07:34:33 +00:00
default :
break ;
}
}
2021-04-05 06:33:56 +00:00
void rigCommander : : parseRegister1B ( )
{
quint16 tone = 0 ;
bool tinv = false ;
bool rinv = false ;
switch ( payloadIn [ 01 ] )
{
case ' \x00 ' :
// "Repeater tone"
tone = decodeTone ( payloadIn ) ;
emit haveTone ( tone ) ;
2022-01-04 18:34:34 +00:00
state . set ( CTCSS , tone , false ) ;
2021-04-05 06:33:56 +00:00
break ;
case ' \x01 ' :
// "TSQL tone"
tone = decodeTone ( payloadIn ) ;
emit haveTSQL ( tone ) ;
2022-01-04 18:34:34 +00:00
state . set ( TSQL , tone , false ) ;
2021-04-05 06:33:56 +00:00
break ;
case ' \x02 ' :
// DTCS (DCS)
tone = decodeTone ( payloadIn , tinv , rinv ) ;
emit haveDTCS ( tone , tinv , rinv ) ;
2022-01-04 18:34:34 +00:00
state . set ( DTCS , tone , false ) ;
2021-04-05 06:33:56 +00:00
break ;
case ' \x07 ' :
// "CSQL code (DV mode)"
2021-05-20 07:31:51 +00:00
tone = decodeTone ( payloadIn ) ;
2022-01-04 18:34:34 +00:00
state . set ( CSQL , tone , false ) ;
2021-04-05 06:33:56 +00:00
break ;
default :
break ;
}
}
2021-04-11 05:48:32 +00:00
void rigCommander : : parseRegister16 ( )
2021-04-05 06:46:44 +00:00
{
//"INDEX: 00 01 02 03 "
//"DATA: 16 5d 00 fd "
// ^-- mode info here
2021-11-22 10:37:21 +00:00
2021-04-11 05:48:32 +00:00
switch ( payloadIn . at ( 1 ) )
{
case ' \x5d ' :
emit haveRptAccessMode ( ( rptAccessTxRx ) payloadIn . at ( 2 ) ) ;
break ;
case ' \x02 ' :
// Preamp
emit havePreamp ( ( unsigned char ) payloadIn . at ( 2 ) ) ;
2022-01-04 18:34:34 +00:00
state . set ( PREAMP , ( quint8 ) payloadIn . at ( 2 ) , false ) ;
break ;
case ' \x22 ' :
state . set ( NBFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
break ;
case ' \x40 ' :
state . set ( NRFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
break ;
case ' \x41 ' : // Auto notch
state . set ( ANFFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
break ;
case ' \x42 ' :
state . set ( TONEFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
break ;
case ' \x43 ' :
state . set ( TSQLFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
break ;
case ' \x44 ' :
state . set ( COMPFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
break ;
case ' \x45 ' :
state . set ( MONFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
break ;
case ' \x46 ' :
state . set ( VOXFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
break ;
case ' \x47 ' :
if ( payloadIn . at ( 2 ) = = ' \00 ' ) {
state . set ( FBKINFUNC , false , false ) ;
state . set ( SBKINFUNC , false , false ) ;
}
else if ( payloadIn . at ( 2 ) = = ' \01 ' ) {
state . set ( FBKINFUNC , false , false ) ;
state . set ( SBKINFUNC , true , false ) ;
}
else if ( payloadIn . at ( 2 ) = = ' \02 ' ) {
state . set ( FBKINFUNC , true , false ) ;
state . set ( SBKINFUNC , false , false ) ;
}
break ;
case ' \x48 ' : // Manual Notch
state . set ( MNFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
break ;
case ' \x50 ' : // Dial lock
state . set ( LOCKFUNC , payloadIn . at ( 2 ) ! = 0 , false ) ;
2021-04-11 05:48:32 +00:00
break ;
default :
break ;
}
2021-04-05 06:46:44 +00:00
}
2018-11-16 22:08:21 +00:00
void rigCommander : : parseBandStackReg ( )
{
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Band stacking register response received: ";
2021-05-07 22:46:47 +00:00
//printHex(payloadIn, false, true);
2021-05-07 21:52:19 +00:00
2018-11-16 22:08:21 +00:00
// Reference output, 20 meters, regCode 01 (latest):
// "INDEX: 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 "
// "DATA: 1a 01 05 01 60 03 23 14 00 00 03 10 00 08 85 00 08 85 fd "
2021-05-07 21:52:19 +00:00
2021-05-15 17:10:08 +00:00
char band = payloadIn [ 2 ] ;
char regCode = payloadIn [ 3 ] ;
2021-03-22 07:11:43 +00:00
freqt freqs = parseFrequency ( payloadIn , 7 ) ;
2021-05-07 21:52:19 +00:00
//float freq = (float)freqs.MHzDouble;
2021-03-22 07:11:43 +00:00
2018-11-16 22:08:21 +00:00
bool dataOn = ( payloadIn [ 11 ] & 0x10 ) > > 4 ; // not sure...
char mode = payloadIn [ 9 ] ;
2021-05-07 21:52:19 +00:00
char filter = payloadIn [ 10 ] ;
2018-11-16 22:08:21 +00:00
// 09, 10 mode
// 11 digit RH: data mode on (1) or off (0)
// 11 digit LH: CTCSS 0 = off, 1 = TONE, 2 = TSQL
// 12, 13 : tone freq setting
// 14, 15 tone squelch freq setting
// if more, memory name (label) ascii
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < " BSR in rigCommander: band: " < < QString ( " %1 " ) . arg ( band ) < < " regCode: " < < ( QString ) regCode < < " freq Hz: " < < freqs . Hz < < " , mode: " < < ( unsigned int ) mode < < " , filter: " < < ( unsigned int ) filter < < " data: " < < dataOn ;
//qInfo(logRig()) << "mode: " << (QString)mode << " dataOn: " << dataOn;
//qInfo(logRig()) << "Freq Hz: " << freqs.Hz;
2021-05-07 21:52:19 +00:00
emit haveBandStackReg ( freqs , mode , filter , dataOn ) ;
2018-11-16 22:08:21 +00:00
}
2018-06-25 07:34:33 +00:00
void rigCommander : : parseDetailedRegisters1A05 ( )
{
// It seems a lot of misc stuff is under this command and subcommand.
2021-02-11 08:33:25 +00:00
// 1A 05 ...
// 00 01 02 03 04 ...
// 02 and 03 make up a BCD'd number:
// 0001, 0002, 0003, ... 0101, 0102, 0103...
2021-02-18 07:26:10 +00:00
// 04 is a typical single byte response
// 04 05 is a typical 0-255 response
// This file processes the registers which are radically different in each model.
// It is a work in progress.
// TODO: inputMod source and gain for models: 7700, and 7600
2021-02-20 08:05:23 +00:00
int level = ( 100 * bcdHexToUChar ( payloadIn [ 4 ] ) ) + bcdHexToUChar ( payloadIn [ 5 ] ) ;
2021-02-18 07:26:10 +00:00
2021-02-19 08:14:40 +00:00
int subcmd = bcdHexToUChar ( payloadIn [ 3 ] ) + ( 100 * bcdHexToUChar ( payloadIn [ 2 ] ) ) ;
2021-02-11 08:33:25 +00:00
2021-02-18 07:26:10 +00:00
rigInput input ;
input = ( rigInput ) bcdHexToUChar ( payloadIn [ 4 ] ) ;
int inputRaw = bcdHexToUChar ( payloadIn [ 4 ] ) ;
switch ( rigCaps . model )
2021-02-11 08:33:25 +00:00
{
2021-02-18 07:26:10 +00:00
case model9700 :
switch ( subcmd )
{
2021-02-19 08:14:40 +00:00
2021-02-18 07:26:10 +00:00
case 72 :
// course reference
emit haveRefAdjustCourse ( bcdHexToUChar ( payloadIn [ 5 ] ) + ( 100 * bcdHexToUChar ( payloadIn [ 4 ] ) ) ) ;
break ;
case 73 :
// fine reference
emit haveRefAdjustFine ( bcdHexToUChar ( payloadIn [ 5 ] ) + ( 100 * bcdHexToUChar ( payloadIn [ 4 ] ) ) ) ;
break ;
case 112 :
2021-02-20 08:05:23 +00:00
emit haveACCGain ( level , 5 ) ;
2021-02-18 07:26:10 +00:00
break ;
case 113 :
emit haveUSBGain ( level ) ;
break ;
case 114 :
emit haveLANGain ( level ) ;
break ;
case 115 :
emit haveModInput ( input , false ) ;
break ;
case 116 :
emit haveModInput ( input , true ) ;
break ;
default :
break ;
}
2021-05-21 22:26:40 +00:00
break ;
2021-02-18 07:26:10 +00:00
case model7850 :
switch ( subcmd )
{
case 63 :
switch ( inputRaw )
{
case 0 :
input = inputMic ;
break ;
case 1 :
input = inputACCA ;
break ;
case 2 :
input = inputACCB ;
break ;
case 8 :
input = inputUSB ;
break ;
case 9 :
input = inputLAN ;
break ;
default :
input = inputUnknown ;
break ;
}
emit haveModInput ( input , false ) ;
break ;
case 64 :
switch ( inputRaw )
{
case 0 :
input = inputMic ;
break ;
case 1 :
input = inputACCA ;
break ;
case 2 :
input = inputACCB ;
break ;
case 8 :
input = inputUSB ;
break ;
case 9 :
input = inputLAN ;
break ;
default :
input = inputUnknown ;
break ;
}
emit haveModInput ( input , true ) ;
break ;
case 58 :
emit haveACCGain ( level , 0 ) ;
break ;
case 59 :
emit haveACCGain ( level , 1 ) ;
break ;
case 61 :
emit haveUSBGain ( level ) ;
break ;
case 62 :
emit haveLANGain ( level ) ;
break ;
2021-04-24 06:24:34 +00:00
default :
break ;
2021-02-18 07:26:10 +00:00
}
2021-05-21 22:26:40 +00:00
break ;
2021-02-18 07:26:10 +00:00
case model7610 :
switch ( subcmd )
{
case 91 :
emit haveModInput ( input , false ) ;
break ;
case 92 :
emit haveModInput ( input , true ) ;
break ;
case 88 :
2021-02-20 08:05:23 +00:00
emit haveACCGain ( level , 5 ) ;
2021-02-18 07:26:10 +00:00
break ;
case 89 :
emit haveUSBGain ( level ) ;
break ;
case 90 :
emit haveLANGain ( level ) ;
break ;
default :
break ;
}
return ;
case model7600 :
switch ( subcmd )
{
case 30 :
emit haveModInput ( input , false ) ;
break ;
case 31 :
emit haveModInput ( input , true ) ;
break ;
case 29 :
emit haveUSBGain ( level ) ;
break ;
default :
break ;
}
return ;
case model7300 :
switch ( subcmd )
{
case 64 :
2021-02-20 08:05:23 +00:00
emit haveACCGain ( level , 5 ) ;
2021-02-18 07:26:10 +00:00
break ;
case 65 :
emit haveUSBGain ( level ) ;
break ;
case 66 :
emit haveModInput ( input , false ) ;
break ;
case 67 :
emit haveModInput ( input , true ) ;
break ;
default :
break ;
}
return ;
case model7100 :
switch ( subcmd )
{
case 87 :
2021-02-20 08:05:23 +00:00
emit haveACCGain ( level , 5 ) ;
2021-02-18 07:26:10 +00:00
break ;
case 89 :
emit haveUSBGain ( level ) ;
break ;
case 90 :
emit haveModInput ( input , false ) ;
break ;
case 91 :
emit haveModInput ( input , true ) ;
break ;
2021-04-24 06:24:34 +00:00
default :
break ;
2021-02-18 07:26:10 +00:00
}
2021-05-21 22:26:40 +00:00
break ;
2021-02-18 07:26:10 +00:00
case model705 :
switch ( subcmd )
{
case 116 :
emit haveUSBGain ( level ) ;
break ;
case 117 :
emit haveLANGain ( level ) ;
break ;
case 118 :
switch ( inputRaw )
{
case 0 :
input = inputMic ;
break ;
case 1 :
input = inputUSB ;
break ;
case 3 :
input = inputLAN ;
break ;
default :
input = inputUnknown ;
break ;
}
emit haveModInput ( input , false ) ;
break ;
case 119 :
switch ( inputRaw )
{
case 0 :
input = inputMic ;
break ;
case 1 :
input = inputUSB ;
break ;
case 3 :
input = inputLAN ;
break ;
default :
input = inputUnknown ;
break ;
}
emit haveModInput ( input , true ) ;
break ;
2021-05-08 20:33:05 +00:00
default :
break ;
2021-02-18 07:26:10 +00:00
}
2021-02-11 08:33:25 +00:00
break ;
2021-02-18 07:26:10 +00:00
2021-02-11 08:33:25 +00:00
default :
break ;
}
2018-06-25 07:34:33 +00:00
}
2018-12-18 22:34:04 +00:00
void rigCommander : : parseWFData ( )
{
2021-04-11 07:42:25 +00:00
freqt freqSpan ;
bool isSub ;
2018-12-18 22:34:04 +00:00
switch ( payloadIn [ 1 ] )
{
case 0 :
// Chunk of spectrum
parseSpectrum ( ) ;
break ;
case 0x10 :
// confirming scope is on
2022-01-04 18:34:34 +00:00
state . set ( SCOPEFUNC , ( bool ) payloadIn [ 2 ] , true ) ;
2018-12-18 22:34:04 +00:00
break ;
case 0x11 :
// confirming output enabled/disabled of wf data.
break ;
case 0x14 :
// fixed or center
2021-03-01 05:41:27 +00:00
emit haveSpectrumMode ( static_cast < spectrumMode > ( ( unsigned char ) payloadIn [ 3 ] ) ) ;
2018-12-18 22:34:04 +00:00
// [1] 0x14
2021-03-01 05:41:27 +00:00
// [2] 0x00
// [3] 0x00 (center), 0x01 (fixed), 0x02, 0x03
2018-12-18 22:34:04 +00:00
break ;
case 0x15 :
// read span in center mode
// [1] 0x15
// [2] to [8] is span encoded as a frequency
2021-04-11 07:42:25 +00:00
isSub = payloadIn . at ( 2 ) = = 0x01 ;
freqSpan = parseFrequency ( payloadIn , 6 ) ;
emit haveScopeSpan ( freqSpan , isSub ) ;
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < " Received 0x15 center span data: for frequency " < < freqSpan . Hz ;
2021-03-22 07:11:43 +00:00
//printHex(payloadIn, false, true);
2018-12-18 22:34:04 +00:00
break ;
case 0x16 :
// read edge mode center in edge mode
emit haveScopeEdge ( ( char ) payloadIn [ 2 ] ) ;
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < " Received 0x16 edge in center mode: " ;
2018-12-18 22:34:04 +00:00
printHex ( payloadIn , false , true ) ;
// [1] 0x16
// [2] 0x01, 0x02, 0x03: Edge 1,2,3
break ;
2021-02-10 17:32:56 +00:00
case 0x17 :
// Hold status (only 9700?)
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < " Received 0x17 hold status - need to deal with this! " ;
2021-02-10 17:32:56 +00:00
printHex ( payloadIn , false , true ) ;
break ;
2018-12-18 22:34:04 +00:00
case 0x19 :
// scope reference level
// [1] 0x19
// [2] 0x00
// [3] 10dB digit, 1dB digit
// [4] 0.1dB digit, 0
// [5] 0x00 = +, 0x01 = -
2021-02-16 06:33:21 +00:00
parseSpectrumRefLevel ( ) ;
2018-12-18 22:34:04 +00:00
break ;
default :
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < " Unknown waveform data received: " ;
2018-12-18 22:34:04 +00:00
printHex ( payloadIn , false , true ) ;
break ;
}
}
2021-05-22 06:46:15 +00:00
mode_info rigCommander : : createMode ( mode_kind m , unsigned char reg , QString name )
{
mode_info mode ;
mode . mk = m ;
mode . reg = reg ;
mode . name = name ;
return mode ;
}
2021-06-19 05:45:12 +00:00
centerSpanData rigCommander : : createScopeCenter ( centerSpansType s , QString name )
{
centerSpanData csd ;
csd . cstype = s ;
csd . name = name ;
return csd ;
}
2021-02-10 17:32:56 +00:00
void rigCommander : : determineRigCaps ( )
{
//TODO: Determine available bands (low priority, rig will reject out of band requests anyway)
2021-04-27 01:24:28 +00:00
std : : vector < bandType > standardHF ;
std : : vector < bandType > standardVU ;
// Most commonly supported "HF" bands:
standardHF = { band6m , band10m , band10m , band12m ,
band15m , band17m , band20m , band30m ,
band40m , band60m , band80m , band160m } ;
standardVU = { band70cm , band2m } ;
2021-05-22 06:46:15 +00:00
std : : vector < mode_info > commonModes ;
commonModes = { createMode ( modeLSB , 0x00 , " LSB " ) , createMode ( modeUSB , 0x01 , " USB " ) ,
createMode ( modeFM , 0x05 , " FM " ) , createMode ( modeAM , 0x02 , " AM " ) ,
createMode ( modeCW , 0x03 , " CW " ) , createMode ( modeCW_R , 0x07 , " CW-R " ) ,
createMode ( modeRTTY , 0x04 , " RTTY " ) , createMode ( modeRTTY_R , 0x08 , " RTTY-R " )
} ;
2021-02-10 17:32:56 +00:00
rigCaps . model = model ;
rigCaps . civ = incomingCIVAddr ;
2021-02-11 17:09:45 +00:00
rigCaps . hasDD = false ;
rigCaps . hasDV = false ;
2021-06-20 20:34:32 +00:00
rigCaps . hasDataModes = true ; // USB-D, LSB-D, etc
2021-02-13 06:42:34 +00:00
rigCaps . hasATU = false ;
2021-02-11 17:09:45 +00:00
2021-04-05 06:33:56 +00:00
rigCaps . hasCTCSS = false ;
rigCaps . hasDTCS = false ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = false ;
rigCaps . hasIFShift = false ;
2021-02-13 18:02:45 +00:00
rigCaps . spectSeqMax = 0 ;
rigCaps . spectAmpMax = 0 ;
rigCaps . spectLenMax = 0 ;
2021-06-19 05:45:12 +00:00
rigCaps . scopeCenterSpans = { createScopeCenter ( cs2p5k , " ±2.5k " ) , createScopeCenter ( cs5k , " ±5k " ) ,
createScopeCenter ( cs10k , " ±10k " ) , createScopeCenter ( cs25k , " ±25k " ) ,
createScopeCenter ( cs50k , " ±50k " ) , createScopeCenter ( cs100k , " ±100k " ) ,
createScopeCenter ( cs250k , " ±250k " ) , createScopeCenter ( cs500k , " ±500k " )
} ;
2021-05-22 08:50:45 +00:00
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = true ; // false for older radios
2021-02-13 18:02:45 +00:00
2021-05-22 08:50:45 +00:00
// Clear inputs/preamps/attenuators lists in case we have re-connected.
rigCaps . preamps . clear ( ) ;
rigCaps . attenuators . clear ( ) ;
rigCaps . inputs . clear ( ) ;
2021-02-19 08:14:40 +00:00
rigCaps . inputs . append ( inputMic ) ;
2021-04-08 06:35:24 +00:00
rigCaps . hasAttenuator = true ; // Verify that all recent rigs have attenuators
rigCaps . attenuators . push_back ( ' \x00 ' ) ;
2021-04-09 22:57:16 +00:00
rigCaps . hasPreamp = true ;
2021-04-08 07:05:40 +00:00
rigCaps . preamps . push_back ( ' \x00 ' ) ;
2021-02-13 18:02:45 +00:00
2021-04-09 22:57:16 +00:00
rigCaps . hasAntennaSel = false ;
2021-07-16 16:08:55 +00:00
rigCaps . hasRXAntenna = false ;
2021-04-09 22:57:16 +00:00
2021-02-12 19:52:16 +00:00
rigCaps . hasTransmit = true ;
2021-06-20 20:34:32 +00:00
rigCaps . hasPTTCommand = true ;
2021-11-06 06:21:36 +00:00
rigCaps . useRTSforPTT = false ;
2021-02-12 19:52:16 +00:00
2021-04-27 01:24:28 +00:00
// Common, reasonable defaults for most supported HF rigs:
rigCaps . bsr [ band160m ] = 0x01 ;
rigCaps . bsr [ band80m ] = 0x02 ;
rigCaps . bsr [ band40m ] = 0x03 ;
rigCaps . bsr [ band30m ] = 0x04 ;
rigCaps . bsr [ band20m ] = 0x05 ;
rigCaps . bsr [ band17m ] = 0x06 ;
rigCaps . bsr [ band15m ] = 0x07 ;
rigCaps . bsr [ band12m ] = 0x08 ;
rigCaps . bsr [ band10m ] = 0x09 ;
rigCaps . bsr [ band6m ] = 0x10 ;
rigCaps . bsr [ bandGen ] = 0x11 ;
// Bands that seem to change with every model:
rigCaps . bsr [ band2m ] = 0x00 ;
rigCaps . bsr [ band70cm ] = 0x00 ;
rigCaps . bsr [ band23cm ] = 0x00 ;
// These bands generally aren't defined:
rigCaps . bsr [ band4m ] = 0x00 ;
rigCaps . bsr [ band60m ] = 0x00 ;
rigCaps . bsr [ bandWFM ] = 0x00 ;
rigCaps . bsr [ bandAir ] = 0x00 ;
rigCaps . bsr [ band630m ] = 0x00 ;
rigCaps . bsr [ band2200m ] = 0x00 ;
2021-02-10 17:32:56 +00:00
switch ( model ) {
case model7300 :
rigCaps . modelName = QString ( " IC-7300 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3073 ;
2021-02-10 17:32:56 +00:00
rigCaps . hasSpectrum = true ;
rigCaps . spectSeqMax = 11 ;
rigCaps . spectAmpMax = 160 ;
rigCaps . spectLenMax = 475 ;
2021-02-19 08:14:40 +00:00
rigCaps . inputs . append ( inputUSB ) ;
rigCaps . inputs . append ( inputACC ) ;
2021-02-10 17:32:56 +00:00
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-02-13 06:42:34 +00:00
rigCaps . hasATU = true ;
2021-04-05 06:33:56 +00:00
rigCaps . hasCTCSS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-04-08 06:35:24 +00:00
rigCaps . attenuators . push_back ( ' \x20 ' ) ;
2021-04-08 07:05:40 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
2021-04-27 01:24:28 +00:00
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( band4m ) ;
rigCaps . bands . push_back ( bandGen ) ;
2021-04-27 19:39:31 +00:00
rigCaps . bands . push_back ( band630m ) ;
rigCaps . bands . push_back ( band2200m ) ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x71 " ) ;
2021-02-10 17:32:56 +00:00
break ;
2021-02-12 19:52:16 +00:00
case modelR8600 :
rigCaps . modelName = QString ( " IC-R8600 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3079 ;
2021-02-12 19:52:16 +00:00
rigCaps . hasSpectrum = true ;
rigCaps . spectSeqMax = 11 ;
rigCaps . spectAmpMax = 160 ;
rigCaps . spectLenMax = 475 ;
2021-02-19 08:14:40 +00:00
rigCaps . inputs . clear ( ) ;
2021-02-12 19:52:16 +00:00
rigCaps . hasLan = true ;
rigCaps . hasEthernet = true ;
rigCaps . hasWiFi = false ;
rigCaps . hasTransmit = false ;
2021-06-20 20:34:32 +00:00
rigCaps . hasPTTCommand = false ;
2021-04-05 06:33:56 +00:00
rigCaps . hasCTCSS = true ;
rigCaps . hasDTCS = true ;
2021-05-01 07:54:42 +00:00
rigCaps . hasDV = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-04-08 06:35:24 +00:00
rigCaps . attenuators . push_back ( ' \x10 ' ) ;
rigCaps . attenuators . push_back ( ' \x20 ' ) ;
rigCaps . attenuators . push_back ( ' \x30 ' ) ;
2021-04-08 07:05:40 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
2021-04-09 22:57:16 +00:00
rigCaps . hasAntennaSel = true ;
2021-05-04 16:42:14 +00:00
rigCaps . antennas = { 0x00 , 0x01 , 0x02 } ;
2021-04-27 01:24:28 +00:00
rigCaps . bands = standardHF ;
rigCaps . bands . insert ( rigCaps . bands . end ( ) , standardVU . begin ( ) , standardVU . end ( ) ) ;
rigCaps . bands . insert ( rigCaps . bands . end ( ) , { band23cm , band4m , band630m , band2200m , bandGen } ) ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
rigCaps . modes . insert ( rigCaps . modes . end ( ) , {
createMode ( modeWFM , 0x06 , " WFM " ) , createMode ( modeS_AMD , 0x11 , " S-AM (D) " ) ,
createMode ( modeS_AML , 0x14 , " S-AM(L) " ) , createMode ( modeS_AMU , 0x15 , " S-AM(U) " ) ,
createMode ( modeP25 , 0x16 , " P25 " ) , createMode ( modedPMR , 0x18 , " dPMR " ) ,
createMode ( modeNXDN_VN , 0x19 , " NXDN-VN " ) , createMode ( modeNXDN_N , 0x20 , " NXDN-N " ) ,
createMode ( modeDCR , 0x21 , " DCR " ) } ) ;
2021-06-19 05:45:12 +00:00
rigCaps . scopeCenterSpans . insert ( rigCaps . scopeCenterSpans . end ( ) , { createScopeCenter ( cs1M , " ±1M " ) , createScopeCenter ( cs2p5M , " ±2.5M " ) } ) ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x92 " ) ;
2021-02-12 19:52:16 +00:00
break ;
2021-02-10 17:32:56 +00:00
case model9700 :
rigCaps . modelName = QString ( " IC-9700 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3081 ;
2021-02-10 17:32:56 +00:00
rigCaps . hasSpectrum = true ;
rigCaps . spectSeqMax = 11 ;
rigCaps . spectAmpMax = 160 ;
rigCaps . spectLenMax = 475 ;
2021-02-19 08:14:40 +00:00
rigCaps . inputs . append ( inputLAN ) ;
rigCaps . inputs . append ( inputUSB ) ;
rigCaps . inputs . append ( inputACC ) ;
2021-02-10 17:32:56 +00:00
rigCaps . hasLan = true ;
rigCaps . hasEthernet = true ;
rigCaps . hasWiFi = false ;
2021-02-11 17:09:45 +00:00
rigCaps . hasDD = true ;
rigCaps . hasDV = true ;
2021-04-05 06:33:56 +00:00
rigCaps . hasCTCSS = true ;
rigCaps . hasDTCS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-04-08 06:35:24 +00:00
rigCaps . attenuators . push_back ( ' \x10 ' ) ;
2021-04-08 07:05:40 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
2021-04-27 01:24:28 +00:00
rigCaps . bands = standardVU ;
rigCaps . bands . push_back ( band23cm ) ;
rigCaps . bsr [ band23cm ] = 0x03 ;
rigCaps . bsr [ band70cm ] = 0x02 ;
rigCaps . bsr [ band2m ] = 0x01 ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
rigCaps . modes . insert ( rigCaps . modes . end ( ) , { createMode ( modeDV , 0x17 , " DV " ) ,
createMode ( modeDD , 0x22 , " DD " ) } ) ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x01 \x27 " ) ;
2021-02-10 17:32:56 +00:00
break ;
2021-05-08 20:45:52 +00:00
case model910h :
rigCaps . modelName = QString ( " IC-910H " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3044 ;
2021-05-08 20:45:52 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-05-08 20:45:52 +00:00
rigCaps . hasDD = false ;
rigCaps . hasDV = false ;
rigCaps . hasCTCSS = true ;
rigCaps . hasDTCS = true ;
rigCaps . hasATU = false ;
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) , { ' \x10 ' , ' \x20 ' , ' \x30 ' } ) ;
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . bands = standardVU ;
rigCaps . bands . push_back ( band23cm ) ;
rigCaps . bsr [ band23cm ] = 0x03 ;
rigCaps . bsr [ band70cm ] = 0x02 ;
rigCaps . bsr [ band2m ] = 0x01 ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x58 " ) ;
2021-05-08 20:45:52 +00:00
break ;
2021-07-09 22:15:04 +00:00
case model7600 :
rigCaps . modelName = QString ( " IC-7600 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3063 ;
2021-07-09 22:15:04 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . append ( inputACC ) ;
rigCaps . inputs . append ( inputUSB ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
rigCaps . hasFDcomms = false ;
rigCaps . hasATU = true ;
rigCaps . hasCTCSS = false ;
rigCaps . hasDTCS = false ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-07-09 22:15:04 +00:00
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) , { 0x00 , 0x06 , 0x12 , 0x18 } ) ;
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
rigCaps . antennas = { 0x00 , 0x01 } ;
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bsr [ bandGen ] = 0x11 ;
rigCaps . modes = commonModes ;
rigCaps . modes . insert ( rigCaps . modes . end ( ) , { createMode ( modePSK , 0x12 , " PSK " ) ,
createMode ( modePSK_R , 0x13 , " PSK-R " ) } ) ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x97 " ) ;
2021-07-09 22:15:04 +00:00
break ;
2021-02-10 17:32:56 +00:00
case model7610 :
rigCaps . modelName = QString ( " IC-7610 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3078 ;
2021-02-10 17:32:56 +00:00
rigCaps . hasSpectrum = true ;
rigCaps . spectSeqMax = 15 ;
rigCaps . spectAmpMax = 200 ;
rigCaps . spectLenMax = 689 ;
2021-02-19 08:14:40 +00:00
rigCaps . inputs . append ( inputLAN ) ;
rigCaps . inputs . append ( inputUSB ) ;
rigCaps . inputs . append ( inputACC ) ;
2021-02-10 17:32:56 +00:00
rigCaps . hasLan = true ;
rigCaps . hasEthernet = true ;
rigCaps . hasWiFi = false ;
2021-04-05 06:33:56 +00:00
rigCaps . hasCTCSS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-04-08 06:35:24 +00:00
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) ,
{ ' \x03 ' , ' \x06 ' , ' \x09 ' , ' \x12 ' , \
' \x15 ' , ' \x18 ' , ' \x21 ' , ' \x24 ' , \
' \x27 ' , ' \x30 ' , ' \x33 ' , ' \x36 ' ,
' \x39 ' , ' \x42 ' , ' \x45 ' } ) ;
2021-04-08 07:05:40 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
2021-04-09 22:57:16 +00:00
rigCaps . hasAntennaSel = true ;
2021-05-04 16:42:14 +00:00
rigCaps . antennas = { 0x00 , 0x01 } ;
2021-04-11 16:38:58 +00:00
rigCaps . hasATU = true ;
2021-04-27 01:24:28 +00:00
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( bandGen ) ;
2021-04-27 19:39:31 +00:00
rigCaps . bands . push_back ( band630m ) ;
rigCaps . bands . push_back ( band2200m ) ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
2021-07-16 16:08:55 +00:00
rigCaps . hasRXAntenna = true ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x01 \x12 " ) ;
2021-02-10 17:32:56 +00:00
break ;
case model7850 :
rigCaps . modelName = QString ( " IC-785x " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3075 ;
2021-02-10 17:32:56 +00:00
rigCaps . hasSpectrum = true ;
rigCaps . spectSeqMax = 15 ;
rigCaps . spectAmpMax = 136 ;
rigCaps . spectLenMax = 689 ;
2021-02-19 08:14:40 +00:00
rigCaps . inputs . append ( inputLAN ) ;
rigCaps . inputs . append ( inputUSB ) ;
rigCaps . inputs . append ( inputACCA ) ;
rigCaps . inputs . append ( inputACCB ) ;
2021-02-10 17:32:56 +00:00
rigCaps . hasLan = true ;
rigCaps . hasEthernet = true ;
rigCaps . hasWiFi = false ;
2021-02-13 06:42:34 +00:00
rigCaps . hasATU = true ;
2021-04-05 06:33:56 +00:00
rigCaps . hasCTCSS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-04-08 06:35:24 +00:00
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) ,
{ ' \x03 ' , ' \x06 ' , ' \x09 ' ,
' \x12 ' , ' \x15 ' , ' \x18 ' , ' \x21 ' } ) ;
2021-04-08 07:05:40 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
2021-04-09 22:57:16 +00:00
rigCaps . hasAntennaSel = true ;
2021-05-04 16:42:14 +00:00
rigCaps . antennas = { 0x00 , 0x01 , 0x02 , 0x03 } ;
2021-04-27 01:24:28 +00:00
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( bandGen ) ;
2021-05-01 05:15:30 +00:00
rigCaps . bands . push_back ( band630m ) ;
rigCaps . bands . push_back ( band2200m ) ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
rigCaps . modes . insert ( rigCaps . modes . end ( ) , { createMode ( modePSK , 0x12 , " PSK " ) ,
createMode ( modePSK_R , 0x13 , " PSK-R " ) } ) ;
2021-07-16 16:08:55 +00:00
rigCaps . hasRXAntenna = true ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x01 \x55 " ) ;
2021-02-10 17:32:56 +00:00
break ;
case model705 :
rigCaps . modelName = QString ( " IC-705 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3085 ;
2021-02-10 17:32:56 +00:00
rigCaps . hasSpectrum = true ;
rigCaps . spectSeqMax = 11 ;
rigCaps . spectAmpMax = 160 ;
rigCaps . spectLenMax = 475 ;
2021-02-19 08:14:40 +00:00
rigCaps . inputs . append ( inputLAN ) ;
rigCaps . inputs . append ( inputUSB ) ;
2021-02-10 17:32:56 +00:00
rigCaps . hasLan = true ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = true ;
2021-02-11 17:09:45 +00:00
rigCaps . hasDD = true ;
rigCaps . hasDV = true ;
2021-02-13 06:42:34 +00:00
rigCaps . hasATU = true ;
2021-04-05 06:33:56 +00:00
rigCaps . hasCTCSS = true ;
rigCaps . hasDTCS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-04-08 07:05:40 +00:00
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) , { ' \x10 ' , ' \x20 ' } ) ;
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
2021-04-27 01:24:28 +00:00
rigCaps . bands = standardHF ;
rigCaps . bands . insert ( rigCaps . bands . end ( ) , standardVU . begin ( ) , standardVU . end ( ) ) ;
rigCaps . bands . push_back ( bandGen ) ;
2021-04-28 03:18:17 +00:00
rigCaps . bands . push_back ( bandAir ) ;
rigCaps . bands . push_back ( bandWFM ) ;
2021-04-27 01:24:28 +00:00
rigCaps . bsr [ band70cm ] = 0x14 ;
rigCaps . bsr [ band2m ] = 0x13 ;
rigCaps . bsr [ bandAir ] = 0x12 ;
rigCaps . bsr [ bandWFM ] = 0x11 ;
rigCaps . bsr [ bandGen ] = 0x15 ;
2021-04-27 19:49:31 +00:00
rigCaps . bands . push_back ( band630m ) ;
rigCaps . bands . push_back ( band2200m ) ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
rigCaps . modes . insert ( rigCaps . modes . end ( ) , { createMode ( modeWFM , 0x06 , " WFM " ) ,
createMode ( modeDV , 0x17 , " DV " ) } ) ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x01 \x31 " ) ;
2021-02-10 17:32:56 +00:00
break ;
2021-05-15 02:04:47 +00:00
case model7000 :
rigCaps . modelName = QString ( " IC-7000 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3060 ;
2021-05-15 02:04:47 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . append ( inputACC ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-05-15 02:04:47 +00:00
rigCaps . hasATU = true ;
rigCaps . hasCTCSS = true ;
rigCaps . hasDTCS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-05-17 02:45:26 +00:00
rigCaps . attenuators . push_back ( ' \x12 ' ) ;
2021-05-15 02:04:47 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . bands = standardHF ;
rigCaps . bands . insert ( rigCaps . bands . end ( ) , standardVU . begin ( ) , standardVU . end ( ) ) ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bsr [ band2m ] = 0x11 ;
rigCaps . bsr [ band70cm ] = 0x12 ;
rigCaps . bsr [ bandGen ] = 0x13 ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x92 " ) ;
2021-05-15 02:04:47 +00:00
break ;
2021-05-15 06:58:22 +00:00
case model7410 :
rigCaps . modelName = QString ( " IC-7410 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3067 ;
2021-05-15 06:58:22 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . append ( inputACC ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = true ;
2021-05-15 06:58:22 +00:00
rigCaps . hasATU = true ;
rigCaps . hasCTCSS = true ;
rigCaps . hasDTCS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-07-26 16:03:09 +00:00
rigCaps . attenuators . push_back ( ' \x20 ' ) ;
2021-05-15 06:58:22 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
rigCaps . antennas = { 0x00 , 0x01 } ;
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bsr [ bandGen ] = 0x11 ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x40 " ) ;
2021-05-15 06:58:22 +00:00
break ;
2021-02-19 08:14:40 +00:00
case model7100 :
rigCaps . modelName = QString ( " IC-7100 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3070 ;
2021-02-19 08:14:40 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . append ( inputUSB ) ;
rigCaps . inputs . append ( inputACC ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-02-19 08:14:40 +00:00
rigCaps . hasATU = true ;
2021-04-05 06:33:56 +00:00
rigCaps . hasCTCSS = true ;
rigCaps . hasDTCS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-04-08 06:35:24 +00:00
rigCaps . attenuators . push_back ( ' \x12 ' ) ;
2021-04-08 07:05:40 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
2021-04-27 01:24:28 +00:00
rigCaps . bands = standardHF ;
rigCaps . bands . insert ( rigCaps . bands . end ( ) , standardVU . begin ( ) , standardVU . end ( ) ) ;
rigCaps . bands . push_back ( band4m ) ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bsr [ band2m ] = 0x11 ;
rigCaps . bsr [ band70cm ] = 0x12 ;
rigCaps . bsr [ bandGen ] = 0x13 ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
rigCaps . modes . insert ( rigCaps . modes . end ( ) , { createMode ( modeWFM , 0x06 , " WFM " ) ,
createMode ( modeDV , 0x17 , " DV " ) } ) ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x95 " ) ;
2021-02-19 08:14:40 +00:00
break ;
2021-05-16 07:07:24 +00:00
case model7200 :
rigCaps . modelName = QString ( " IC-7200 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3061 ;
2021-05-16 07:07:24 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . append ( inputUSB ) ;
rigCaps . inputs . append ( inputACC ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-05-16 07:07:24 +00:00
rigCaps . hasATU = true ;
rigCaps . hasCTCSS = true ;
rigCaps . hasDTCS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-05-16 07:07:24 +00:00
rigCaps . attenuators . push_back ( ' \x20 ' ) ;
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bsr [ bandGen ] = 0x11 ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x03 \x48 " ) ;
break ;
2021-05-31 21:01:13 +00:00
case model7700 :
rigCaps . modelName = QString ( " IC-7700 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3062 ;
2021-05-31 21:01:13 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . append ( inputLAN ) ;
//rigCaps.inputs.append(inputSPDIF);
rigCaps . inputs . append ( inputACC ) ;
rigCaps . hasLan = true ;
rigCaps . hasEthernet = true ;
rigCaps . hasWiFi = false ;
rigCaps . hasCTCSS = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-05-31 21:01:13 +00:00
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) ,
{ ' \x06 ' , ' \x12 ' , ' \x18 ' } ) ;
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
rigCaps . hasAntennaSel = true ;
rigCaps . antennas = { 0x00 , 0x01 , 0x02 , 0x03 } ; // not sure if 0x03 works
rigCaps . hasATU = true ;
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bands . push_back ( band630m ) ;
rigCaps . bands . push_back ( band2200m ) ;
rigCaps . modes = commonModes ;
rigCaps . modes . insert ( rigCaps . modes . end ( ) , { createMode ( modePSK , 0x12 , " PSK " ) ,
createMode ( modePSK_R , 0x13 , " PSK-R " ) } ) ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x95 " ) ;
2021-05-16 07:07:24 +00:00
break ;
2021-02-13 18:02:45 +00:00
case model706 :
rigCaps . modelName = QString ( " IC-706 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3009 ;
2021-02-13 18:02:45 +00:00
rigCaps . hasSpectrum = false ;
2021-02-19 08:14:40 +00:00
rigCaps . inputs . clear ( ) ;
2021-02-13 18:02:45 +00:00
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-02-13 18:02:45 +00:00
rigCaps . hasATU = true ;
2021-06-20 20:34:32 +00:00
rigCaps . hasPTTCommand = false ;
2021-11-06 06:21:36 +00:00
rigCaps . useRTSforPTT = true ;
2021-06-20 20:34:32 +00:00
rigCaps . hasDataModes = false ;
2021-04-08 06:35:24 +00:00
rigCaps . attenuators . push_back ( ' \x20 ' ) ;
2021-04-27 01:24:28 +00:00
rigCaps . bands = standardHF ;
rigCaps . bands . insert ( rigCaps . bands . end ( ) , standardVU . begin ( ) , standardVU . end ( ) ) ;
rigCaps . bands . push_back ( bandGen ) ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
rigCaps . modes . insert ( rigCaps . modes . end ( ) , createMode ( modeWFM , 0x06 , " WFM " ) ) ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x00 " ) ;
2021-02-13 18:02:45 +00:00
break ;
2021-06-08 21:42:19 +00:00
case model718 :
rigCaps . modelName = QString ( " IC-718 " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3013 ;
2021-06-08 21:42:19 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . clear ( ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-06-08 21:42:19 +00:00
rigCaps . hasATU = false ;
2021-06-20 20:34:32 +00:00
rigCaps . hasPTTCommand = false ;
2021-11-06 06:21:36 +00:00
rigCaps . useRTSforPTT = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasIFShift = true ;
2021-06-20 20:34:32 +00:00
rigCaps . hasDataModes = false ;
2021-06-08 21:42:19 +00:00
rigCaps . attenuators . push_back ( ' \x20 ' ) ;
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . bands = { band10m , band10m , band12m ,
band15m , band17m , band20m , band30m ,
band40m , band60m , band80m , band160m , bandGen } ;
rigCaps . modes = { createMode ( modeLSB , 0x00 , " LSB " ) , createMode ( modeUSB , 0x01 , " USB " ) ,
createMode ( modeAM , 0x02 , " AM " ) ,
createMode ( modeCW , 0x03 , " CW " ) , createMode ( modeCW_R , 0x07 , " CW-R " ) ,
createMode ( modeRTTY , 0x04 , " RTTY " ) , createMode ( modeRTTY_R , 0x08 , " RTTY-R " )
} ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x00 " ) ;
2021-06-08 21:42:19 +00:00
break ;
2021-08-17 21:00:37 +00:00
case model736 :
rigCaps . modelName = QString ( " IC-736 " ) ;
rigCaps . rigctlModel = 3020 ;
rigCaps . hasSpectrum = false ;
rigCaps . inputs . clear ( ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
rigCaps . hasFDcomms = false ;
rigCaps . hasATU = false ;
rigCaps . hasPTTCommand = false ;
2021-11-06 06:21:36 +00:00
rigCaps . useRTSforPTT = true ;
2021-08-17 21:00:37 +00:00
rigCaps . hasDataModes = false ;
2021-11-05 17:09:31 +00:00
rigCaps . hasIFShift = true ; // untested
2021-08-17 21:00:37 +00:00
rigCaps . attenuators . push_back ( ' \x20 ' ) ;
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . bands = standardHF ;
rigCaps . modes = { createMode ( modeLSB , 0x00 , " LSB " ) , createMode ( modeUSB , 0x01 , " USB " ) ,
2021-11-05 03:45:02 +00:00
createMode ( modeAM , 0x02 , " AM " ) , createMode ( modeFM , 0x05 , " FM " ) ,
2021-08-17 21:00:37 +00:00
createMode ( modeCW , 0x03 , " CW " ) , createMode ( modeCW_R , 0x07 , " CW-R " ) ,
} ;
break ;
2022-02-08 01:31:29 +00:00
case model746 :
rigCaps . modelName = QString ( " IC-746 " ) ;
rigCaps . rigctlModel = 3023 ;
rigCaps . hasSpectrum = false ;
rigCaps . inputs . clear ( ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
rigCaps . hasFDcomms = false ;
rigCaps . hasATU = true ;
rigCaps . hasTBPF = true ;
rigCaps . hasIFShift = true ;
rigCaps . hasCTCSS = true ;
rigCaps . hasDTCS = true ;
rigCaps . hasAntennaSel = true ;
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) , { ' \x20 ' } ) ;
// There are two HF and VHF ant, 12-01 adn 12-02 select the HF, the VHF is auto selected
// this incorrectly shows up as 2 and 3 in the drop down.
rigCaps . antennas = { 0x01 , 0x02 } ;
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( band2m ) ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . modes = commonModes ;
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x00 " ) ;
break ;
2021-05-20 23:15:25 +00:00
case model756pro :
rigCaps . modelName = QString ( " IC-756 Pro " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3027 ;
2021-05-20 23:15:25 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . clear ( ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-05-20 23:15:25 +00:00
rigCaps . hasATU = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-05-20 23:15:25 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) , { ' \x06 ' , ' \x12 ' , ' \x18 ' } ) ;
rigCaps . antennas = { 0x00 , 0x01 } ;
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bsr [ bandGen ] = 0x11 ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x00 " ) ;
2021-05-22 06:46:15 +00:00
break ;
case model756proii :
rigCaps . modelName = QString ( " IC-756 Pro II " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3027 ;
2021-05-22 06:46:15 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . clear ( ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-05-22 06:46:15 +00:00
rigCaps . hasATU = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-05-22 06:46:15 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) , { ' \x06 ' , ' \x12 ' , ' \x18 ' } ) ;
rigCaps . antennas = { 0x00 , 0x01 } ;
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bsr [ bandGen ] = 0x11 ;
rigCaps . modes = commonModes ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x00 " ) ;
2021-05-20 23:15:25 +00:00
break ;
2021-05-20 22:57:30 +00:00
case model756proiii :
rigCaps . modelName = QString ( " IC-756 Pro III " ) ;
2021-08-07 17:34:34 +00:00
rigCaps . rigctlModel = 3027 ;
2021-05-20 22:57:30 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . inputs . clear ( ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-05-20 22:57:30 +00:00
rigCaps . hasATU = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-05-20 22:57:30 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) , { ' \x06 ' , ' \x12 ' , ' \x18 ' } ) ;
rigCaps . antennas = { 0x00 , 0x01 } ;
rigCaps . bands = standardHF ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bsr [ bandGen ] = 0x11 ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x00 " ) ;
2021-05-20 22:57:30 +00:00
break ;
2021-08-17 16:35:40 +00:00
case model9100 :
rigCaps . modelName = QString ( " IC-9100 " ) ;
rigCaps . rigctlModel = 3068 ;
rigCaps . hasSpectrum = false ;
rigCaps . inputs . append ( inputUSB ) ; // TODO, add commands for this radio's inputs
rigCaps . inputs . append ( inputACC ) ;
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
rigCaps . hasFDcomms = false ;
rigCaps . hasATU = true ;
rigCaps . hasDV = true ;
2021-11-05 17:09:31 +00:00
rigCaps . hasTBPF = true ;
2021-08-17 16:35:40 +00:00
rigCaps . preamps . push_back ( ' \x01 ' ) ;
rigCaps . preamps . push_back ( ' \x02 ' ) ;
rigCaps . attenuators . insert ( rigCaps . attenuators . end ( ) , { ' \x20 ' } ) ;
rigCaps . antennas = { 0x00 , 0x01 } ;
rigCaps . bands = standardHF ;
rigCaps . bands . insert ( rigCaps . bands . end ( ) , standardVU . begin ( ) , standardVU . end ( ) ) ;
rigCaps . bands . push_back ( band23cm ) ;
rigCaps . bands . push_back ( bandGen ) ;
rigCaps . bsr [ band2m ] = 0x11 ;
rigCaps . bsr [ band70cm ] = 0x12 ;
rigCaps . bsr [ band23cm ] = 0x13 ;
rigCaps . bsr [ bandGen ] = 0x14 ;
rigCaps . modes = commonModes ;
rigCaps . modes . insert ( rigCaps . modes . end ( ) , { createMode ( modeDV , 0x17 , " DV " ) } ) ;
break ;
2021-02-10 17:32:56 +00:00
default :
2021-05-20 04:51:24 +00:00
rigCaps . modelName = QString ( " IC-0x%1 " ) . arg ( rigCaps . modelID , 2 , 16 ) ;
2021-02-10 17:32:56 +00:00
rigCaps . hasSpectrum = false ;
rigCaps . spectSeqMax = 0 ;
rigCaps . spectAmpMax = 0 ;
rigCaps . spectLenMax = 0 ;
2021-02-19 08:14:40 +00:00
rigCaps . inputs . clear ( ) ;
2021-02-10 17:32:56 +00:00
rigCaps . hasLan = false ;
rigCaps . hasEthernet = false ;
rigCaps . hasWiFi = false ;
2021-06-18 19:41:56 +00:00
rigCaps . hasFDcomms = false ;
2021-04-09 22:57:16 +00:00
rigCaps . hasPreamp = false ;
rigCaps . hasAntennaSel = false ;
2021-04-08 06:35:24 +00:00
rigCaps . attenuators . push_back ( ' \x10 ' ) ;
2021-04-09 17:04:20 +00:00
rigCaps . attenuators . push_back ( ' \x12 ' ) ;
2021-04-08 06:35:24 +00:00
rigCaps . attenuators . push_back ( ' \x20 ' ) ;
2021-04-27 01:24:28 +00:00
rigCaps . bands = standardHF ;
rigCaps . bands . insert ( rigCaps . bands . end ( ) , standardVU . begin ( ) , standardVU . end ( ) ) ;
rigCaps . bands . insert ( rigCaps . bands . end ( ) , { band23cm , band4m , band630m , band2200m , bandGen } ) ;
2021-05-22 06:46:15 +00:00
rigCaps . modes = commonModes ;
2021-08-28 23:16:31 +00:00
rigCaps . transceiveCommand = QByteArrayLiteral ( " \x1a \x05 \x00 \x00 " ) ;
2021-05-22 06:46:15 +00:00
qInfo ( logRig ( ) ) < < " Found unknown rig: 0x " < < QString ( " %1 " ) . arg ( rigCaps . modelID , 2 , 16 ) ;
2021-02-10 17:32:56 +00:00
break ;
}
haveRigCaps = true ;
2021-07-16 16:08:55 +00:00
2022-01-26 09:49:52 +00:00
// Copy received guid so we can recognise this radio.
2022-01-29 22:50:58 +00:00
memcpy ( rigCaps . guid , this - > guid , GUIDLEN ) ;
2022-01-26 09:49:52 +00:00
2021-11-07 05:49:10 +00:00
if ( ! usingNativeLAN )
2022-01-04 18:34:34 +00:00
{
if ( useRTSforPTT_isSet )
{
rigCaps . useRTSforPTT = useRTSforPTT_manual ;
}
2021-11-07 05:49:10 +00:00
comm - > setUseRTSforPTT ( rigCaps . useRTSforPTT ) ;
2022-01-04 18:34:34 +00:00
}
2021-11-07 05:49:10 +00:00
2021-02-10 17:32:56 +00:00
if ( lookingForRig )
{
lookingForRig = false ;
foundRig = true ;
2021-05-15 17:53:16 +00:00
2021-02-23 21:21:22 +00:00
qDebug ( logRig ( ) ) < < " ---Rig FOUND from broadcast query: " ;
2021-02-10 17:32:56 +00:00
this - > civAddr = incomingCIVAddr ; // Override and use immediately.
payloadPrefix = QByteArray ( " \xFE \xFE " ) ;
payloadPrefix . append ( civAddr ) ;
2021-02-22 11:11:08 +00:00
payloadPrefix . append ( ( char ) compCivAddr ) ;
2021-02-10 17:32:56 +00:00
// if there is a compile-time error, remove the following line, the "hex" part is the issue:
2022-04-28 09:52:46 +00:00
qInfo ( logRig ( ) ) < < " Using incomingCIVAddr: (int): " < < this - > civAddr < < " hex: " < < QString ( " 0x%1 " ) . arg ( this - > civAddr , 0 , 16 ) ;
2021-02-10 17:32:56 +00:00
emit discoveredRigID ( rigCaps ) ;
} else {
2021-05-15 23:57:08 +00:00
if ( ! foundRig )
{
emit discoveredRigID ( rigCaps ) ;
foundRig = true ;
}
2021-02-10 17:32:56 +00:00
emit haveRigID ( rigCaps ) ;
}
}
2018-06-19 19:58:52 +00:00
void rigCommander : : parseSpectrum ( )
{
2021-02-10 17:32:56 +00:00
if ( ! haveRigCaps )
{
2021-02-23 21:21:22 +00:00
qDebug ( logRig ( ) ) < < " Spectrum received in rigCommander, but rigID is incomplete. " ;
2021-02-10 17:32:56 +00:00
return ;
}
if ( rigCaps . spectSeqMax = = 0 )
{
// there is a chance this will happen with rigs that support spectrum. Once our RigID query returns, we will parse correctly.
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < " Warning: Spectrum sequence max was zero, yet spectrum was received. " ;
2021-02-10 17:32:56 +00:00
return ;
}
2018-06-19 19:58:52 +00:00
// Here is what to expect:
// payloadIn[00] = '\x27';
// payloadIn[01] = '\x00';
// payloadIn[02] = '\x00';
//
// Example long: (sequences 2-10, 50 pixels)
// "INDEX: 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 "
// "DATA: 27 00 00 07 11 27 13 15 01 00 22 21 09 08 06 19 0e 20 23 25 2c 2d 17 27 29 16 14 1b 1b 21 27 1a 18 17 1e 21 1b 24 21 22 23 13 19 23 2f 2d 25 25 0a 0e 1e 20 1f 1a 0c fd "
// ^--^--(seq 7/11)
// ^-- start waveform data 0x00 to 0xA0, index 05 to 54
//
// Example medium: (sequence #11)
// "INDEX: 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 "
// "DATA: 27 00 00 11 11 0b 13 21 23 1a 1b 22 1e 1a 1d 13 21 1d 26 28 1f 19 1a 18 09 2c 2c 2c 1a 1b fd "
// Example short: (sequence #1) includes center/fixed mode at [05]. No pixels.
// "INDEX: 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 "
// "DATA: 27 00 00 01 11 01 00 00 00 14 00 00 00 35 14 00 00 fd "
// ^-- mode 00 (center) or 01 (fixed)
// ^--14.00 MHz lower edge
// ^-- 14.350 MHz upper edge
// ^-- possibly 00=in range 01 = out of range
// Note, the index used here, -1, matches the ICD in the owner's manual.
// Owner's manual + 1 = our index.
// divs: Mode: Waveinfo: Len: Comment:
// 2-10 var var 56 Minimum wave information w/waveform data
// 11 10 26 31 Minimum wave information w/waveform data
// 1 1 0 18 Only Wave Information without waveform data
2021-03-22 07:11:43 +00:00
freqt fStart ;
freqt fEnd ;
2021-02-16 06:33:21 +00:00
unsigned char sequence = bcdHexToUChar ( payloadIn [ 03 ] ) ;
2018-06-19 19:58:52 +00:00
//unsigned char sequenceMax = bcdHexToDecimal(payloadIn[04]);
2021-02-10 17:32:56 +00:00
2018-06-19 19:58:52 +00:00
// unsigned char waveInfo = payloadIn[06]; // really just one byte?
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Spectrum Data received: " << sequence << "/" << sequenceMax << " mode: " << scopeMode << " waveInfo: " << waveInfo << " length: " << payloadIn.length();
2018-06-19 19:58:52 +00:00
// Sequnce 2, index 05 is the start of data
// Sequence 11. index 05, is the last chunk
// Sequence 11, index 29, is the actual last pixel (it seems)
// It looks like the data length may be variable, so we need to detect it each time.
// start at payloadIn.length()-1 (to override the FD). Never mind, index -1 bad.
// chop off FD.
2021-02-10 17:32:56 +00:00
if ( ( sequence = = 1 ) & & ( sequence < rigCaps . spectSeqMax ) )
2018-06-19 19:58:52 +00:00
{
2021-02-10 17:32:56 +00:00
2021-03-01 05:41:27 +00:00
spectrumMode scopeMode = ( spectrumMode ) bcdHexToUChar ( payloadIn [ 05 ] ) ; // 0=center, 1=fixed
2021-02-10 17:32:56 +00:00
if ( scopeMode ! = oldScopeMode )
{
2021-03-01 05:41:27 +00:00
//TODO: support the other two modes (firmware 1.40)
// Modes:
// 0x00 Center
// 0x01 Fixed
// 0x02 Scroll-C
// 0x03 Scroll-F
emit haveSpectrumMode ( scopeMode ) ;
2021-02-10 17:32:56 +00:00
oldScopeMode = scopeMode ;
}
2018-06-19 19:58:52 +00:00
// wave information
spectrumLine . clear ( ) ;
2021-03-01 05:41:27 +00:00
// For Fixed, and both scroll modes, the following produces correct information:
2021-03-22 07:11:43 +00:00
fStart = parseFrequency ( payloadIn , 9 ) ;
spectrumStartFreq = fStart . MHzDouble ;
fEnd = parseFrequency ( payloadIn , 14 ) ;
spectrumEndFreq = fEnd . MHzDouble ;
2021-03-01 05:41:27 +00:00
if ( scopeMode = = spectModeCenter )
2018-06-19 19:58:52 +00:00
{
2022-03-23 15:45:51 +00:00
// "center" mode, start is actual center, end is bandwidth.
2018-06-19 19:58:52 +00:00
spectrumStartFreq - = spectrumEndFreq ;
spectrumEndFreq = spectrumStartFreq + 2 * ( spectrumEndFreq ) ;
2021-03-03 04:47:20 +00:00
// emit haveSpectrumCenterSpan(span);
2018-06-19 19:58:52 +00:00
}
2021-05-02 04:53:05 +00:00
2021-02-10 17:32:56 +00:00
if ( payloadIn . length ( ) > 400 ) // Must be a LAN packet.
{
payloadIn . chop ( 1 ) ;
//spectrumLine.append(payloadIn.mid(17,475)); // write over the FD, last one doesn't, oh well.
spectrumLine . append ( payloadIn . right ( payloadIn . length ( ) - 17 ) ) ; // write over the FD, last one doesn't, oh well.
emit haveSpectrumData ( spectrumLine , spectrumStartFreq , spectrumEndFreq ) ;
}
} else if ( ( sequence > 1 ) & & ( sequence < rigCaps . spectSeqMax ) )
2018-06-19 19:58:52 +00:00
{
// spectrum from index 05 to index 54, length is 55 per segment. Length is 56 total. Pixel data is 50 pixels.
// sequence numbers 2 through 10, 50 pixels each. Total after sequence 10 is 450 pixels.
payloadIn . chop ( 1 ) ;
spectrumLine . insert ( spectrumLine . length ( ) , payloadIn . right ( payloadIn . length ( ) - 5 ) ) ; // write over the FD, last one doesn't, oh well.
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "sequence: " << sequence << "spec index: " << (sequence-2)*55 << " payloadPosition: " << payloadIn.length() - 5 << " payload length: " << payloadIn.length();
2021-02-10 17:32:56 +00:00
} else if ( sequence = = rigCaps . spectSeqMax )
2018-06-19 19:58:52 +00:00
{
2021-02-10 17:32:56 +00:00
// last spectrum, a little bit different (last 25 pixels). Total at end is 475 pixels (7300).
2018-06-19 19:58:52 +00:00
payloadIn . chop ( 1 ) ;
spectrumLine . insert ( spectrumLine . length ( ) , payloadIn . right ( payloadIn . length ( ) - 5 ) ) ;
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "sequence: " << sequence << " spec index: " << (sequence-2)*55 << " payloadPosition: " << payloadIn.length() - 5 << " payload length: " << payloadIn.length();
2018-06-19 19:58:52 +00:00
emit haveSpectrumData ( spectrumLine , spectrumStartFreq , spectrumEndFreq ) ;
}
}
2021-02-16 06:33:21 +00:00
void rigCommander : : parseSpectrumRefLevel ( )
{
// 00: 27
// 01: 19
// 02: 00 (fixed)
// 03: XX
// 04: x0
// 05: 00 (+) or 01 (-)
unsigned char negative = payloadIn [ 5 ] ;
int value = bcdHexToUInt ( payloadIn [ 3 ] , payloadIn [ 4 ] ) ;
value = value / 10 ;
if ( negative ) {
value * = ( - 1 * negative ) ;
}
emit haveSpectrumRefLevel ( value ) ;
}
unsigned char rigCommander : : bcdHexToUChar ( unsigned char in )
2018-06-19 19:58:52 +00:00
{
unsigned char out = 0 ;
out = in & 0x0f ;
out + = ( ( in & 0xf0 ) > > 4 ) * 10 ;
return out ;
}
2021-02-16 06:33:21 +00:00
unsigned int rigCommander : : bcdHexToUInt ( unsigned char hundreds , unsigned char tensunits )
{
// convert:
// hex data: 0x41 0x23
// convert to uint:
// uchar: 4123
unsigned char thousands = ( ( hundreds & 0xf0 ) > > 4 ) ;
unsigned int rtnVal ;
rtnVal = ( hundreds & 0x0f ) * 100 ;
rtnVal + = ( ( tensunits & 0xf0 ) > > 4 ) * 10 ;
rtnVal + = ( tensunits & 0x0f ) ;
rtnVal + = thousands * 1000 ;
return rtnVal ;
}
unsigned char rigCommander : : bcdHexToUChar ( unsigned char hundreds , unsigned char tensunits )
2021-02-11 08:33:25 +00:00
{
// convert:
// hex data: 0x01 0x23
// convert to uchar:
// uchar: 123
2021-02-16 06:33:21 +00:00
//unsigned char thousands = ((hundreds & 0xf0)>>4);
2021-02-11 08:33:25 +00:00
unsigned char rtnVal ;
rtnVal = ( hundreds & 0x0f ) * 100 ;
rtnVal + = ( ( tensunits & 0xf0 ) > > 4 ) * 10 ;
rtnVal + = ( tensunits & 0x0f ) ;
2021-02-16 06:33:21 +00:00
//rtnVal += thousands * 1000;
2021-02-11 08:33:25 +00:00
return rtnVal ;
}
QByteArray rigCommander : : bcdEncodeInt ( unsigned int num )
{
if ( num > 9999 )
{
2021-05-15 17:53:16 +00:00
qInfo ( logRig ( ) ) < < __FUNCTION__ < < " Error, number is too big for four-digit conversion: " < < num ;
2021-02-11 08:33:25 +00:00
return QByteArray ( ) ;
}
char thousands = num / 1000 ;
char hundreds = ( num - ( 1000 * thousands ) ) / 100 ;
char tens = ( num - ( 1000 * thousands ) - ( 100 * hundreds ) ) / 10 ;
char units = ( num - ( 1000 * thousands ) - ( 100 * hundreds ) - ( 10 * tens ) ) ;
char b0 = hundreds | ( thousands < < 4 ) ;
char b1 = units | ( tens < < 4 ) ;
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << __FUNCTION__ << " encoding value " << num << " as hex:";
2021-02-11 08:33:25 +00:00
//printHex(QByteArray(b0), false, true);
//printHex(QByteArray(b1), false, true);
QByteArray result ;
result . append ( b0 ) . append ( b1 ) ;
return result ;
}
2018-06-19 19:58:52 +00:00
void rigCommander : : parseFrequency ( )
{
2021-03-22 07:11:43 +00:00
freqt freq ;
freq . Hz = 0 ;
freq . MHzDouble = 0 ;
2018-06-19 19:58:52 +00:00
// process payloadIn, which is stripped.
// float frequencyMhz
// payloadIn[04] = ; // XX MHz
// payloadIn[03] = ; // XX0 KHz
// payloadIn[02] = ; // X.X KHz
// payloadIn[01] = ; // . XX KHz
// printHex(payloadIn, false, true);
2021-02-10 17:32:56 +00:00
frequencyMhz = 0.0 ;
2022-01-04 18:34:34 +00:00
if ( payloadIn . length ( ) = = 7 )
2021-02-10 17:32:56 +00:00
{
// 7300 has these digits too, as zeros.
// IC-705 or IC-9700 with higher frequency data available.
2022-01-04 18:34:34 +00:00
frequencyMhz + = 100 * ( payloadIn [ 05 ] & 0x0f ) ;
frequencyMhz + = ( 1000 * ( ( payloadIn [ 05 ] & 0xf0 ) > > 4 ) ) ;
2021-03-22 07:11:43 +00:00
2022-01-04 18:34:34 +00:00
freq . Hz + = ( payloadIn [ 05 ] & 0x0f ) * 1E6 * 100 ;
freq . Hz + = ( ( payloadIn [ 05 ] & 0xf0 ) > > 4 ) * 1E6 * 1000 ;
2021-03-22 07:11:43 +00:00
2021-02-10 17:32:56 +00:00
}
2021-03-22 07:11:43 +00:00
freq . Hz + = ( payloadIn [ 04 ] & 0x0f ) * 1E6 ;
2022-01-04 18:34:34 +00:00
freq . Hz + = ( ( payloadIn [ 04 ] & 0xf0 ) > > 4 ) * 1E6 * 10 ;
2021-03-22 07:11:43 +00:00
2021-02-10 17:32:56 +00:00
frequencyMhz + = payloadIn [ 04 ] & 0x0f ;
2022-01-04 18:34:34 +00:00
frequencyMhz + = 10 * ( ( payloadIn [ 04 ] & 0xf0 ) > > 4 ) ;
2018-06-19 19:58:52 +00:00
2021-03-22 07:11:43 +00:00
// KHz land:
2022-01-04 18:34:34 +00:00
frequencyMhz + = ( ( payloadIn [ 03 ] & 0xf0 ) > > 4 ) / 10.0 ;
2018-06-19 19:58:52 +00:00
frequencyMhz + = ( payloadIn [ 03 ] & 0x0f ) / 100.0 ;
frequencyMhz + = ( ( payloadIn [ 02 ] & 0xf0 ) > > 4 ) / 1000.0 ;
frequencyMhz + = ( payloadIn [ 02 ] & 0x0f ) / 10000.0 ;
2022-01-04 18:34:34 +00:00
frequencyMhz + = ( ( payloadIn [ 01 ] & 0xf0 ) > > 4 ) / 100000.0 ;
frequencyMhz + = ( payloadIn [ 01 ] & 0x0f ) / 1000000.0 ;
2021-03-22 07:11:43 +00:00
freq . Hz + = payloadIn [ 01 ] & 0x0f ;
2022-01-04 18:34:34 +00:00
freq . Hz + = ( ( payloadIn [ 01 ] & 0xf0 ) > > 4 ) * 10 ;
2018-06-19 19:58:52 +00:00
2022-01-04 18:34:34 +00:00
freq . Hz + = ( payloadIn [ 02 ] & 0x0f ) * 100 ;
freq . Hz + = ( ( payloadIn [ 02 ] & 0xf0 ) > > 4 ) * 1000 ;
2021-03-22 07:11:43 +00:00
2022-01-04 18:34:34 +00:00
freq . Hz + = ( payloadIn [ 03 ] & 0x0f ) * 10000 ;
freq . Hz + = ( ( payloadIn [ 03 ] & 0xf0 ) > > 4 ) * 100000 ;
2021-03-22 07:11:43 +00:00
freq . MHzDouble = frequencyMhz ;
2022-01-04 18:34:34 +00:00
if ( state . getChar ( CURRENTVFO ) = = 0 ) {
state . set ( VFOAFREQ , freq . Hz , false ) ;
}
else {
state . set ( VFOBFREQ , freq . Hz , false ) ;
}
2021-03-22 07:11:43 +00:00
emit haveFrequency ( freq ) ;
2018-06-19 19:58:52 +00:00
}
2021-03-22 07:11:43 +00:00
freqt rigCommander : : parseFrequency ( QByteArray data , unsigned char lastPosition )
2018-06-19 19:58:52 +00:00
{
// process payloadIn, which is stripped.
// float frequencyMhz
// payloadIn[04] = ; // XX MHz
// payloadIn[03] = ; // XX0 KHz
// payloadIn[02] = ; // X.X KHz
// payloadIn[01] = ; // . XX KHz
//printHex(data, false, true);
2021-04-11 07:42:25 +00:00
// TODO: Check length of data array prior to reading +/- position
2021-04-25 07:23:52 +00:00
// NOTE: This function was written on the IC-7300, which has no need for 100 MHz and 1 GHz.
// Therefore, this function has to go to position +1 to retrieve those numbers for the IC-9700.
2021-04-11 07:42:25 +00:00
// TODO: 64-bit value is incorrect, multiplying by wrong numbers.
2018-06-19 19:58:52 +00:00
float freq = 0.0 ;
2021-03-22 07:11:43 +00:00
freqt freqs ;
freqs . MHzDouble = 0 ;
freqs . Hz = 0 ;
// MHz:
2021-02-10 17:32:56 +00:00
freq + = 100 * ( data [ lastPosition + 1 ] & 0x0f ) ;
freq + = ( 1000 * ( ( data [ lastPosition + 1 ] & 0xf0 ) > > 4 ) ) ;
freq + = data [ lastPosition ] & 0x0f ;
2018-06-19 19:58:52 +00:00
freq + = 10 * ( ( data [ lastPosition ] & 0xf0 ) > > 4 ) ;
2021-03-22 07:11:43 +00:00
freqs . Hz + = ( data [ lastPosition ] & 0x0f ) * 1E6 ;
2021-04-25 07:23:52 +00:00
freqs . Hz + = ( ( data [ lastPosition ] & 0xf0 ) > > 4 ) * 1E6 * 10 ; // 10 MHz
if ( data . length ( ) > = lastPosition + 1 )
{
freqs . Hz + = ( data [ lastPosition + 1 ] & 0x0f ) * 1E6 * 100 ; // 100 MHz
freqs . Hz + = ( ( data [ lastPosition + 1 ] & 0xf0 ) > > 4 ) * 1E6 * 1000 ; // 1000 MHz
}
2021-03-22 07:11:43 +00:00
// Hz:
2018-06-19 19:58:52 +00:00
freq + = ( ( data [ lastPosition - 1 ] & 0xf0 ) > > 4 ) / 10.0 ;
freq + = ( data [ lastPosition - 1 ] & 0x0f ) / 100.0 ;
freq + = ( ( data [ lastPosition - 2 ] & 0xf0 ) > > 4 ) / 1000.0 ;
freq + = ( data [ lastPosition - 2 ] & 0x0f ) / 10000.0 ;
freq + = ( ( data [ lastPosition - 3 ] & 0xf0 ) > > 4 ) / 100000.0 ;
freq + = ( data [ lastPosition - 3 ] & 0x0f ) / 1000000.0 ;
2021-04-25 07:23:52 +00:00
freqs . Hz + = ( data [ lastPosition - 1 ] & 0x0f ) * 10E3 ; // 10 KHz
freqs . Hz + = ( ( data [ lastPosition - 1 ] & 0xf0 ) > > 4 ) * 100E3 ; // 100 KHz
2021-03-22 07:11:43 +00:00
2021-04-25 07:23:52 +00:00
freqs . Hz + = ( data [ lastPosition - 2 ] & 0x0f ) * 100 ; // 100 Hz
freqs . Hz + = ( ( data [ lastPosition - 2 ] & 0xf0 ) > > 4 ) * 1000 ; // 1 KHz
2021-03-22 07:11:43 +00:00
2021-04-25 07:23:52 +00:00
freqs . Hz + = ( data [ lastPosition - 3 ] & 0x0f ) * 1 ; // 1 Hz
freqs . Hz + = ( ( data [ lastPosition - 3 ] & 0xf0 ) > > 4 ) * 10 ; // 10 Hz
2021-03-22 07:11:43 +00:00
2021-05-02 04:53:05 +00:00
freqs . MHzDouble = ( double ) ( freqs . Hz / 1000000.0 ) ;
2021-03-22 07:11:43 +00:00
return freqs ;
2018-06-19 19:58:52 +00:00
}
void rigCommander : : parseMode ( )
{
2021-02-14 07:42:51 +00:00
unsigned char filter ;
if ( payloadIn [ 2 ] ! = ' \xFD ' )
2018-06-19 19:58:52 +00:00
{
2021-02-14 07:42:51 +00:00
filter = payloadIn [ 2 ] ;
} else {
filter = 0 ;
2018-06-19 19:58:52 +00:00
}
2021-02-14 07:42:51 +00:00
emit haveMode ( ( unsigned char ) payloadIn [ 01 ] , filter ) ;
2022-01-04 18:34:34 +00:00
state . set ( MODE , ( unsigned char ) payloadIn [ 01 ] , false ) ;
state . set ( FILTER , filter , false ) ;
2018-06-19 19:58:52 +00:00
}
2018-11-17 06:19:44 +00:00
void rigCommander : : startATU ( )
{
QByteArray payload ( " \x1C \x01 \x02 " ) ;
prepDataAndSend ( payload ) ;
}
2018-11-17 07:13:59 +00:00
void rigCommander : : setATU ( bool enabled )
{
QByteArray payload ;
if ( enabled )
{
payload . setRawData ( " \x1C \x01 \x01 " , 3 ) ;
} else {
payload . setRawData ( " \x1C \x01 \x00 " , 3 ) ;
}
prepDataAndSend ( payload ) ;
}
void rigCommander : : getATUStatus ( )
{
2021-05-15 17:53:16 +00:00
//qInfo(logRig()) << "Sending out for ATU status in RC.";
2018-11-17 07:13:59 +00:00
QByteArray payload ( " \x1C \x01 " ) ;
prepDataAndSend ( payload ) ;
}
2021-04-08 06:35:24 +00:00
void rigCommander : : getAttenuator ( )
{
QByteArray payload ( " \x11 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getPreamp ( )
{
QByteArray payload ( " \x16 \x02 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getAntenna ( )
{
2022-03-23 15:45:51 +00:00
// This one might need some thought
2021-04-08 06:35:24 +00:00
// as it seems each antenna has to be checked.
// Maybe 0x12 alone will do it.
QByteArray payload ( " \x12 " ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setAttenuator ( unsigned char att )
{
QByteArray payload ( " \x11 " ) ;
payload . append ( att ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setPreamp ( unsigned char pre )
{
QByteArray payload ( " \x16 \x02 " ) ;
payload . append ( pre ) ;
prepDataAndSend ( payload ) ;
}
2021-07-16 16:08:55 +00:00
void rigCommander : : setAntenna ( unsigned char ant , bool rx )
2021-04-08 06:35:24 +00:00
{
QByteArray payload ( " \x12 " ) ;
payload . append ( ant ) ;
2021-09-22 09:39:35 +00:00
if ( rigCaps . hasRXAntenna ) {
payload . append ( ( unsigned char ) rx ) ; // 0x00 = use for TX and RX
}
2021-04-08 06:35:24 +00:00
prepDataAndSend ( payload ) ;
}
2022-01-04 18:34:34 +00:00
void rigCommander : : setNb ( bool enabled ) {
QByteArray payload ( " \x16 \x22 " ) ;
payload . append ( ( unsigned char ) enabled ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getNb ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x22 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setNr ( bool enabled ) {
QByteArray payload ( " \x16 \x40 " ) ;
payload . append ( ( unsigned char ) enabled ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getNr ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x40 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setAutoNotch ( bool enabled )
{
QByteArray payload ( " \x16 \x41 " ) ;
payload . append ( ( unsigned char ) enabled ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getAutoNotch ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x41 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setToneEnabled ( bool enabled )
{
QByteArray payload ( " \x16 \x42 " ) ;
payload . append ( ( unsigned char ) enabled ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getToneEnabled ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x42 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setToneSql ( bool enabled )
{
QByteArray payload ( " \x16 \x43 " ) ;
payload . append ( ( unsigned char ) enabled ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getToneSql ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x43 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setCompressor ( bool enabled )
{
QByteArray payload ( " \x16 \x44 " ) ;
payload . append ( ( unsigned char ) enabled ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getCompressor ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x44 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setMonitor ( bool enabled )
{
QByteArray payload ( " \x16 \x45 " ) ;
payload . append ( ( unsigned char ) enabled ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getMonitor ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x45 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setVox ( bool enabled )
{
QByteArray payload ( " \x16 \x46 " ) ;
payload . append ( ( unsigned char ) enabled ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getVox ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x46 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setBreakIn ( unsigned char type ) {
QByteArray payload ( " \x16 \x47 " ) ;
payload . append ( ( unsigned char ) type ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getBreakIn ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x47 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : setManualNotch ( bool enabled )
{
QByteArray payload ( " \x16 \x48 " ) ;
payload . append ( ( unsigned char ) enabled ) ;
prepDataAndSend ( payload ) ;
}
void rigCommander : : getManualNotch ( )
{
QByteArray payload ;
payload . setRawData ( " \x16 \x48 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
2018-11-20 07:42:34 +00:00
void rigCommander : : getRigID ( )
{
QByteArray payload ;
payload . setRawData ( " \x19 \x00 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
2021-11-07 06:59:03 +00:00
void rigCommander : : setRigID ( unsigned char rigID )
{
// This function overrides radio model detection.
// It can be used for radios without Rig ID commands,
// or to force a specific radio model
qInfo ( logRig ( ) ) < < " Sending rig ID to: (int) " < < ( int ) rigID ;
lookingForRig = true ;
foundRig = false ;
2021-11-07 07:24:08 +00:00
// needed because this is a fake message and thus the value is uninitialized
// this->civAddr comes from how rigCommander is setup and should be accurate.
this - > incomingCIVAddr = this - > civAddr ;
2021-11-07 06:59:03 +00:00
this - > model = determineRadioModel ( rigID ) ;
rigCaps . modelID = rigID ;
rigCaps . model = determineRadioModel ( rigID ) ;
determineRigCaps ( ) ;
}
2021-02-27 00:37:00 +00:00
void rigCommander : : changeLatency ( const quint16 value )
2021-02-10 17:32:56 +00:00
{
2021-02-27 00:37:00 +00:00
emit haveChangeLatency ( value ) ;
2021-02-10 17:32:56 +00:00
}
2019-02-01 20:21:54 +00:00
void rigCommander : : sayAll ( )
{
QByteArray payload ;
payload . setRawData ( " \x13 \x00 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
2018-11-20 07:42:34 +00:00
2019-02-01 20:21:54 +00:00
void rigCommander : : sayFrequency ( )
{
QByteArray payload ;
payload . setRawData ( " \x13 \x01 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
2018-11-20 07:42:34 +00:00
2019-02-01 20:21:54 +00:00
void rigCommander : : sayMode ( )
{
QByteArray payload ;
payload . setRawData ( " \x13 \x02 " , 2 ) ;
prepDataAndSend ( payload ) ;
}
2018-11-20 07:42:34 +00:00
// Other:
2018-06-19 19:58:52 +00:00
QByteArray rigCommander : : stripData ( const QByteArray & data , unsigned char cutPosition )
{
QByteArray rtndata ;
if ( data . length ( ) < cutPosition )
{
return rtndata ;
}
rtndata = data . right ( cutPosition ) ;
return rtndata ;
}
2021-08-04 19:49:32 +00:00
void rigCommander : : sendState ( )
{
2022-01-04 18:34:34 +00:00
emit stateInfo ( & state ) ;
}
2022-01-21 19:23:32 +00:00
void rigCommander : : radioSelection ( QList < radio_cap_packet > radios )
{
emit requestRadioSelection ( radios ) ;
}
2022-01-23 17:54:40 +00:00
void rigCommander : : radioUsage ( quint8 radio , quint8 busy , QString user , QString ip ) {
2022-01-21 23:58:18 +00:00
emit setRadioUsage ( radio , busy , user , ip ) ;
2022-01-21 19:23:32 +00:00
}
2022-01-23 17:54:40 +00:00
void rigCommander : : setCurrentRadio ( quint8 radio ) {
2022-01-21 23:58:18 +00:00
emit selectedRadio ( radio ) ;
}
2022-01-21 19:23:32 +00:00
2022-01-04 18:34:34 +00:00
void rigCommander : : stateUpdated ( )
{
// A remote process has updated the rigState
// First we need to find which item(s) have been updated and send the command(s) to the rig.
QMap < stateTypes , value > : : iterator i = state . map . begin ( ) ;
while ( i ! = state . map . end ( ) ) {
if ( ! i . value ( ) . _valid | | i . value ( ) . _updated )
{
i . value ( ) . _updated = false ;
i . value ( ) . _valid = true ; // Set value to valid as we have requested it (even if we haven't had a response)
qDebug ( logRigCtlD ( ) ) < < " Got new value: " < < i . key ( ) < < " = " < < i . value ( ) . _value ;
switch ( i . key ( ) ) {
case VFOAFREQ :
if ( i . value ( ) . _valid ) {
freqt freq ;
freq . Hz = state . getInt64 ( VFOAFREQ ) ;
setFrequency ( 0 , freq ) ;
setFrequency ( 0 , freq ) ;
setFrequency ( 0 , freq ) ;
}
getFrequency ( ) ;
break ;
case VFOBFREQ :
if ( i . value ( ) . _valid ) {
freqt freq ;
freq . Hz = state . getInt64 ( VFOBFREQ ) ;
setFrequency ( 1 , freq ) ;
setFrequency ( 1 , freq ) ;
setFrequency ( 1 , freq ) ;
}
getFrequency ( ) ;
break ;
case CURRENTVFO :
// Work on VFOB - how do we do this?
break ;
case PTT :
if ( i . value ( ) . _valid ) {
setPTT ( state . getBool ( PTT ) ) ;
setPTT ( state . getBool ( PTT ) ) ;
setPTT ( state . getBool ( PTT ) ) ;
}
getPTT ( ) ;
break ;
case MODE :
case FILTER :
if ( i . value ( ) . _valid ) {
setMode ( state . getChar ( MODE ) , state . getChar ( FILTER ) ) ;
}
getMode ( ) ;
break ;
case DUPLEX :
if ( i . value ( ) . _valid ) {
setDuplexMode ( state . getDuplex ( DUPLEX ) ) ;
}
getDuplexMode ( ) ;
break ;
case DATAMODE :
if ( i . value ( ) . _valid ) {
setDataMode ( state . getBool ( DATAMODE ) , state . getChar ( FILTER ) ) ;
}
getDuplexMode ( ) ;
break ;
case ANTENNA :
case RXANTENNA :
if ( i . value ( ) . _valid ) {
setAntenna ( state . getChar ( ANTENNA ) , state . getBool ( RXANTENNA ) ) ;
}
getAntenna ( ) ;
break ;
case CTCSS :
if ( i . value ( ) . _valid ) {
setTone ( state . getChar ( CTCSS ) ) ;
}
getTone ( ) ;
break ;
case TSQL :
if ( i . value ( ) . _valid ) {
setTSQL ( state . getChar ( TSQL ) ) ;
}
getTSQL ( ) ;
break ;
case DTCS :
if ( i . value ( ) . _valid ) {
setDTCS ( state . getChar ( DTCS ) , false , false ) ; // Not sure about this?
}
getDTCS ( ) ;
break ;
case CSQL :
if ( i . value ( ) . _valid ) {
setTone ( state . getChar ( CSQL ) ) ;
}
getTone ( ) ;
break ;
case PREAMP :
if ( i . value ( ) . _valid ) {
setPreamp ( state . getChar ( PREAMP ) ) ;
}
getPreamp ( ) ;
break ;
case ATTENUATOR :
if ( i . value ( ) . _valid ) {
setAttenuator ( state . getChar ( ATTENUATOR ) ) ;
}
getAttenuator ( ) ;
break ;
case AFGAIN :
if ( i . value ( ) . _valid ) {
setAfGain ( state . getChar ( AFGAIN ) ) ;
}
getAfGain ( ) ;
break ;
case RFGAIN :
if ( i . value ( ) . _valid ) {
setRfGain ( state . getChar ( RFGAIN ) ) ;
}
getRfGain ( ) ;
break ;
case SQUELCH :
if ( i . value ( ) . _valid ) {
setSquelch ( state . getChar ( SQUELCH ) ) ;
}
getSql ( ) ;
break ;
2022-03-19 19:05:46 +00:00
case RFPOWER :
2022-01-04 18:34:34 +00:00
if ( i . value ( ) . _valid ) {
2022-03-19 19:05:46 +00:00
setTxPower ( state . getChar ( RFPOWER ) ) ;
2022-01-04 18:34:34 +00:00
}
getTxLevel ( ) ;
break ;
case MICGAIN :
if ( i . value ( ) . _valid ) {
setMicGain ( state . getChar ( MICGAIN ) ) ;
}
getMicGain ( ) ;
break ;
case COMPLEVEL :
if ( i . value ( ) . _valid ) {
setCompLevel ( state . getChar ( COMPLEVEL ) ) ;
}
getCompLevel ( ) ;
break ;
case MONITORLEVEL :
if ( i . value ( ) . _valid ) {
setMonitorLevel ( state . getChar ( MONITORLEVEL ) ) ;
}
getMonitorLevel ( ) ;
break ;
case VOXGAIN :
if ( i . value ( ) . _valid ) {
setVoxGain ( state . getChar ( VOXGAIN ) ) ;
}
getVoxGain ( ) ;
break ;
case ANTIVOXGAIN :
if ( i . value ( ) . _valid ) {
setAntiVoxGain ( state . getChar ( ANTIVOXGAIN ) ) ;
}
getAntiVoxGain ( ) ;
break ;
case NBFUNC :
if ( i . value ( ) . _valid ) {
setNb ( state . getBool ( NBFUNC ) ) ;
}
getNb ( ) ;
break ;
case NRFUNC :
if ( i . value ( ) . _valid ) {
setNr ( state . getBool ( NRFUNC ) ) ;
}
getNr ( ) ;
break ;
case ANFFUNC :
if ( i . value ( ) . _valid ) {
setAutoNotch ( state . getBool ( ANFFUNC ) ) ;
}
getAutoNotch ( ) ;
break ;
case TONEFUNC :
if ( i . value ( ) . _valid ) {
setToneEnabled ( state . getBool ( TONEFUNC ) ) ;
}
getToneEnabled ( ) ;
break ;
case TSQLFUNC :
if ( i . value ( ) . _valid ) {
setToneSql ( state . getBool ( TSQLFUNC ) ) ;
}
getToneSql ( ) ;
break ;
case COMPFUNC :
if ( i . value ( ) . _valid ) {
setCompressor ( state . getBool ( COMPFUNC ) ) ;
}
getCompressor ( ) ;
break ;
case MONFUNC :
if ( i . value ( ) . _valid ) {
setMonitor ( state . getBool ( MONFUNC ) ) ;
}
getMonitor ( ) ;
break ;
case VOXFUNC :
if ( i . value ( ) . _valid ) {
setVox ( state . getBool ( VOXFUNC ) ) ;
}
getVox ( ) ;
break ;
case SBKINFUNC :
if ( i . value ( ) . _valid ) {
setBreakIn ( state . getBool ( VOXFUNC ) ) ;
}
getVox ( ) ;
break ;
case FBKINFUNC :
if ( i . value ( ) . _valid ) {
setBreakIn ( state . getBool ( VOXFUNC ) < < 1 ) ;
}
getBreakIn ( ) ;
break ;
case MNFUNC :
if ( i . value ( ) . _valid ) {
setManualNotch ( state . getBool ( MNFUNC ) ) ;
}
getManualNotch ( ) ;
break ;
case SCOPEFUNC :
if ( i . value ( ) . _valid ) {
if ( state . getBool ( SCOPEFUNC ) ) {
enableSpectOutput ( ) ;
}
else {
disableSpectOutput ( ) ;
}
}
break ;
case RIGINPUT :
if ( i . value ( ) . _valid ) {
setModInput ( state . getInput ( RIGINPUT ) , state . getBool ( DATAMODE ) ) ;
}
getModInput ( state . getBool ( DATAMODE ) ) ;
break ;
case POWERONOFF :
if ( i . value ( ) . _valid ) {
if ( state . getBool ( POWERONOFF ) ) {
powerOn ( ) ;
}
else {
powerOff ( ) ;
}
}
break ;
case RITVALUE :
if ( i . value ( ) . _valid ) {
setRitValue ( state . getInt32 ( RITVALUE ) ) ;
}
getRitValue ( ) ;
break ;
case RITFUNC :
if ( i . value ( ) . _valid ) {
setRitEnable ( state . getBool ( RITFUNC ) ) ;
}
getRitEnabled ( ) ;
break ;
// All meters can only be updated from the rig end.
case SMETER :
2022-01-23 16:43:58 +00:00
case SWRMETER :
2022-01-04 18:34:34 +00:00
case POWERMETER :
case ALCMETER :
case COMPMETER :
case VOLTAGEMETER :
case CURRENTMETER :
break ;
case AGC :
break ;
case MODINPUT :
break ;
case FAGCFUNC :
break ;
case AIPFUNC :
break ;
case APFFUNC :
break ;
case RFFUNC : // Should this set RF output power to 0?
break ;
case AROFUNC :
break ;
case MUTEFUNC :
if ( i . value ( ) . _valid ) {
setAfMute ( state . getBool ( MUTEFUNC ) ) ;
}
getAfMute ( ) ;
break ;
case VSCFUNC :
break ;
case REVFUNC :
break ;
case SQLFUNC :
break ;
case ABMFUNC :
break ;
case BCFUNC :
break ;
case MBCFUNC :
break ;
case AFCFUNC :
break ;
case SATMODEFUNC :
break ;
case NBLEVEL :
break ;
case NBDEPTH :
break ;
case NBWIDTH :
break ;
case NRLEVEL :
break ;
case RESUMEFUNC :
break ;
case TBURSTFUNC :
break ;
case TUNERFUNC :
if ( i . value ( ) . _valid ) {
setATU ( state . getBool ( TUNERFUNC ) ) ;
}
getATUStatus ( ) ;
break ;
case LOCKFUNC :
if ( i . value ( ) . _valid ) {
setDialLock ( state . getBool ( LOCKFUNC ) ) ;
}
getDialLock ( ) ;
break ;
}
}
+ + i ;
}
2021-08-04 19:49:32 +00:00
}
2018-06-19 19:58:52 +00:00
void rigCommander : : getDebug ( )
{
// generic debug function for development.
emit getMoreDebug ( ) ;
}
2021-02-17 08:00:28 +00:00
void rigCommander : : printHex ( const QByteArray & pdata )
{
printHex ( pdata , false , true ) ;
}
2018-06-19 19:58:52 +00:00
void rigCommander : : printHex ( const QByteArray & pdata , bool printVert , bool printHoriz )
{
2021-02-23 21:21:22 +00:00
qDebug ( logRig ( ) ) < < " ---- Begin hex dump -----: " ;
2018-06-19 19:58:52 +00:00
QString sdata ( " DATA: " ) ;
QString index ( " INDEX: " ) ;
QStringList strings ;
for ( int i = 0 ; i < pdata . length ( ) ; i + + )
{
strings < < QString ( " [%1]: %2 " ) . arg ( i , 8 , 10 , QChar ( ' 0 ' ) ) . arg ( ( unsigned char ) pdata [ i ] , 2 , 16 , QChar ( ' 0 ' ) ) ;
sdata . append ( QString ( " %1 " ) . arg ( ( unsigned char ) pdata [ i ] , 2 , 16 , QChar ( ' 0 ' ) ) ) ;
index . append ( QString ( " %1 " ) . arg ( i , 2 , 10 , QChar ( ' 0 ' ) ) ) ;
}
if ( printVert )
{
for ( int i = 0 ; i < strings . length ( ) ; i + + )
{
//sdata = QString(strings.at(i));
2021-02-23 21:21:22 +00:00
qDebug ( logRig ( ) ) < < strings . at ( i ) ;
2018-06-19 19:58:52 +00:00
}
}
if ( printHoriz )
{
2021-02-23 21:21:22 +00:00
qDebug ( logRig ( ) ) < < index ;
qDebug ( logRig ( ) ) < < sdata ;
2018-06-19 19:58:52 +00:00
}
2021-02-23 21:21:22 +00:00
qDebug ( logRig ( ) ) < < " ----- End hex dump ----- " ;
2018-06-19 19:58:52 +00:00
}
2021-02-18 09:14:41 +00:00
void rigCommander : : dataFromServer ( QByteArray data )
{
2022-04-20 12:35:23 +00:00
//qInfo(logRig()) << "***************** emit dataForComm()" << data;
2021-02-18 09:14:41 +00:00
emit dataForComm ( data ) ;
}
2022-01-26 09:49:52 +00:00
quint8 * rigCommander : : getGUID ( ) {
return guid ;
}
2018-06-19 19:58:52 +00:00