kopia lustrzana https://gitlab.com/eliggett/wfview
Change rigstate to a class
rodzic
9ba216f1d9
commit
c5d2ecb793
559
rigcommander.cpp
559
rigcommander.cpp
|
@ -22,20 +22,16 @@
|
|||
|
||||
rigCommander::rigCommander()
|
||||
{
|
||||
rigState.mutex = new QMutex();
|
||||
QMutexLocker locker(rigState.mutex);
|
||||
rigState.filter = 0;
|
||||
rigState.mode = 0;
|
||||
rigState.ptt = 0;
|
||||
rigState.currentVfo = 0;
|
||||
rigState.duplex = dmSplitOff;
|
||||
|
||||
state.filter(0,NONE);
|
||||
state.mode(0,NONE);
|
||||
state.ptt(0,NONE);
|
||||
state.currentVfo(0,NONE);
|
||||
state.duplex(dmSplitOff,NONE);
|
||||
}
|
||||
|
||||
rigCommander::~rigCommander()
|
||||
{
|
||||
closeComm();
|
||||
delete rigState.mutex;
|
||||
}
|
||||
|
||||
|
||||
|
@ -572,16 +568,12 @@ void rigCommander::setFrequency(unsigned char vfo, freqt freq)
|
|||
|
||||
cmdPayload.append(freqPayload);
|
||||
if (vfo == 0) {
|
||||
rigState.mutex->lock();
|
||||
rigState.vfoAFreq = freq;
|
||||
rigState.mutex->unlock();
|
||||
state.vfoAFreq(freq.Hz,NONE);
|
||||
cmdPayload.prepend('\x00');
|
||||
}
|
||||
else
|
||||
{
|
||||
rigState.mutex->lock();
|
||||
rigState.vfoBFreq = freq;
|
||||
rigState.mutex->unlock();
|
||||
state.vfoBFreq(freq.Hz,NONE);
|
||||
cmdPayload.prepend(vfo);
|
||||
cmdPayload.prepend('\x25');
|
||||
}
|
||||
|
@ -709,10 +701,6 @@ void rigCommander::setMode(mode_info m)
|
|||
payload.append(m.filter);
|
||||
|
||||
prepDataAndSend(payload);
|
||||
|
||||
QMutexLocker locker(rigState.mutex);
|
||||
rigState.mode = m.reg;
|
||||
rigState.filter = m.filter;
|
||||
}
|
||||
|
||||
void rigCommander::setMode(unsigned char mode, unsigned char modeFilter)
|
||||
|
@ -742,10 +730,6 @@ void rigCommander::setMode(unsigned char mode, unsigned char modeFilter)
|
|||
}
|
||||
|
||||
prepDataAndSend(payload);
|
||||
QMutexLocker locker(rigState.mutex);
|
||||
rigState.mode = mode;
|
||||
rigState.filter = modeFilter;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -763,8 +747,6 @@ void rigCommander::setDataMode(bool dataOn, unsigned char filter)
|
|||
payload.append("\x00\x00", 2); // data mode off, bandwidth not defined per ICD.
|
||||
}
|
||||
prepDataAndSend(payload);
|
||||
QMutexLocker locker(rigState.mutex);
|
||||
rigState.datamode = dataOn;
|
||||
}
|
||||
|
||||
void rigCommander::getFrequency()
|
||||
|
@ -1008,9 +990,9 @@ void rigCommander::getPTT()
|
|||
//{
|
||||
// emit havePTTStatus(comm->rtsStatus());
|
||||
//} else {
|
||||
QByteArray payload;
|
||||
payload.setRawData("\x1C\x00", 2);
|
||||
prepDataAndSend(payload);
|
||||
QByteArray payload;
|
||||
payload.setRawData("\x1C\x00", 2);
|
||||
prepDataAndSend(payload);
|
||||
//}
|
||||
}
|
||||
|
||||
|
@ -1031,8 +1013,6 @@ void rigCommander::setPTT(bool pttOn)
|
|||
QByteArray payload("\x1C\x00", 2);
|
||||
payload.append((char)pttOn);
|
||||
prepDataAndSend(payload);
|
||||
QMutexLocker locker(rigState.mutex);
|
||||
rigState.ptt = pttOn;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1253,22 +1233,16 @@ void rigCommander::parseCommand()
|
|||
break;
|
||||
case '\x0F':
|
||||
emit haveDuplexMode((duplexMode)(unsigned char)payloadIn[1]);
|
||||
rigState.mutex->lock();
|
||||
rigState.duplex = (duplexMode)(unsigned char)payloadIn[1];
|
||||
rigState.mutex->unlock();
|
||||
state.duplex((duplexMode)(unsigned char)payloadIn[1],NONE);
|
||||
break;
|
||||
case '\x11':
|
||||
emit haveAttenuator((unsigned char)payloadIn.at(1));
|
||||
rigState.mutex->lock();
|
||||
rigState.attenuator = (unsigned char)payloadIn.at(1);
|
||||
rigState.mutex->unlock();
|
||||
state.attenuator((unsigned char)payloadIn.at(1),NONE);
|
||||
break;
|
||||
case '\x12':
|
||||
emit haveAntenna((unsigned char)payloadIn.at(1), (bool)payloadIn.at(2));
|
||||
rigState.mutex->lock();
|
||||
rigState.antenna = (unsigned char)payloadIn.at(1);
|
||||
rigState.rxAntenna = (bool)payloadIn.at(2);
|
||||
rigState.mutex->unlock();
|
||||
state.antenna((unsigned char)payloadIn.at(1),NONE);
|
||||
state.rxAntenna((bool)payloadIn.at(2),NONE);
|
||||
break;
|
||||
case '\x14':
|
||||
// read levels
|
||||
|
@ -1372,24 +1346,18 @@ void rigCommander::parseLevels()
|
|||
// AF level - ignore if LAN connection.
|
||||
if (udp == Q_NULLPTR) {
|
||||
emit haveAfGain(level);
|
||||
rigState.mutex->lock();
|
||||
rigState.afGain = level;
|
||||
rigState.mutex->unlock();
|
||||
state.afGain(level,NONE);
|
||||
}
|
||||
break;
|
||||
case '\x02':
|
||||
// RX RF Gain
|
||||
emit haveRfGain(level);
|
||||
rigState.mutex->lock();
|
||||
rigState.rfGain = level;
|
||||
rigState.mutex->unlock();
|
||||
state.rfGain(level,NONE);
|
||||
break;
|
||||
case '\x03':
|
||||
// Squelch level
|
||||
emit haveSql(level);
|
||||
rigState.mutex->lock();
|
||||
rigState.squelch = level;
|
||||
rigState.mutex->unlock();
|
||||
emit haveSql(level);
|
||||
state.squelch(level,NONE);
|
||||
break;
|
||||
case '\x07':
|
||||
// Twin BPF Inner, or, IF-Shift level
|
||||
|
@ -1408,16 +1376,12 @@ void rigCommander::parseLevels()
|
|||
case '\x0A':
|
||||
// TX RF level
|
||||
emit haveTxPower(level);
|
||||
rigState.mutex->lock();
|
||||
rigState.txPower = level;
|
||||
rigState.mutex->unlock();
|
||||
state.txPower(level,NONE);
|
||||
break;
|
||||
case '\x0B':
|
||||
// Mic Gain
|
||||
emit haveMicGain(level);
|
||||
rigState.mutex->lock();
|
||||
rigState.micGain = level;
|
||||
rigState.mutex->unlock();
|
||||
state.micGain(level,NONE);
|
||||
break;
|
||||
case '\x0C':
|
||||
// CW Keying Speed - ignore for now
|
||||
|
@ -1428,9 +1392,7 @@ void rigCommander::parseLevels()
|
|||
case '\x0E':
|
||||
// compressor level
|
||||
emit haveCompLevel(level);
|
||||
rigState.mutex->lock();
|
||||
rigState.compLevel = level;
|
||||
rigState.mutex->unlock();
|
||||
state.compLevel(level,NONE);
|
||||
break;
|
||||
case '\x12':
|
||||
// NB level - ignore for now
|
||||
|
@ -1438,23 +1400,17 @@ void rigCommander::parseLevels()
|
|||
case '\x15':
|
||||
// monitor level
|
||||
emit haveMonitorLevel(level);
|
||||
rigState.mutex->lock();
|
||||
rigState.monitorLevel = level;
|
||||
rigState.mutex->unlock();
|
||||
state.monitorLevel(level,NONE);
|
||||
break;
|
||||
case '\x16':
|
||||
// VOX gain
|
||||
emit haveVoxGain(level);
|
||||
rigState.mutex->lock();
|
||||
rigState.voxGain = level;
|
||||
rigState.mutex->unlock();
|
||||
state.voxGain(level,NONE);
|
||||
break;
|
||||
case '\x17':
|
||||
// anti-VOX gain
|
||||
emit haveAntiVoxGain(level);
|
||||
rigState.mutex->lock();
|
||||
rigState.antiVoxGain = level;
|
||||
rigState.mutex->unlock();
|
||||
state.antiVoxGain(level,NONE);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
@ -1472,58 +1428,42 @@ void rigCommander::parseLevels()
|
|||
case '\x02':
|
||||
// S-Meter
|
||||
emit haveMeter(meterS, level);
|
||||
rigState.mutex->lock();
|
||||
rigState.sMeter = level;
|
||||
rigState.mutex->unlock();
|
||||
state.sMeter(level,NONE);
|
||||
break;
|
||||
case '\x04':
|
||||
// Center (IC-R8600)
|
||||
emit haveMeter(meterCenter, level);
|
||||
rigState.mutex->lock();
|
||||
rigState.sMeter = level;
|
||||
rigState.mutex->unlock();
|
||||
state.sMeter(level,NONE);
|
||||
break;
|
||||
case '\x11':
|
||||
// RF-Power meter
|
||||
emit haveMeter(meterPower, level);
|
||||
rigState.mutex->lock();
|
||||
rigState.powerMeter = level;
|
||||
rigState.mutex->unlock();
|
||||
state.powerMeter(level,NONE);
|
||||
break;
|
||||
case '\x12':
|
||||
// SWR
|
||||
emit haveMeter(meterSWR, level);
|
||||
rigState.mutex->lock();
|
||||
rigState.swrMeter = level;
|
||||
rigState.mutex->unlock();
|
||||
state.swrMeter(level,NONE);
|
||||
break;
|
||||
case '\x13':
|
||||
// ALC
|
||||
emit haveMeter(meterALC, level);
|
||||
rigState.mutex->lock();
|
||||
rigState.alcMeter = level;
|
||||
rigState.mutex->unlock();
|
||||
state.alcMeter(level,NONE);
|
||||
break;
|
||||
case '\x14':
|
||||
// COMP dB reduction
|
||||
emit haveMeter(meterComp, level);
|
||||
rigState.mutex->lock();
|
||||
rigState.compMeter = level;
|
||||
rigState.mutex->unlock();
|
||||
state.compMeter(level,NONE);
|
||||
break;
|
||||
case '\x15':
|
||||
// VD (12V)
|
||||
emit haveMeter(meterVoltage, level);
|
||||
rigState.mutex->lock();
|
||||
rigState.voltageMeter = level;
|
||||
rigState.mutex->unlock();
|
||||
state.voltageMeter(level,NONE);
|
||||
break;
|
||||
case '\x16':
|
||||
// ID
|
||||
emit haveMeter(meterCurrent, level);
|
||||
rigState.mutex->lock();
|
||||
rigState.currentMeter = level;
|
||||
rigState.mutex->unlock();
|
||||
state.currentMeter(level,NONE);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
@ -2430,8 +2370,7 @@ void rigCommander::parsePTT()
|
|||
// PTT on
|
||||
emit havePTTStatus(true);
|
||||
}
|
||||
QMutexLocker locker(rigState.mutex);
|
||||
rigState.ptt = (bool)payloadIn[2];
|
||||
state.ptt((bool)payloadIn[2],NONE);
|
||||
|
||||
}
|
||||
|
||||
|
@ -2450,7 +2389,6 @@ void rigCommander::parseRegisters1A()
|
|||
|
||||
// "INDEX: 00 01 02 03 04 "
|
||||
// "DATA: 1a 06 01 03 fd " (data mode enabled, filter width 3 selected)
|
||||
QMutexLocker locker(rigState.mutex);
|
||||
|
||||
switch(payloadIn[01])
|
||||
{
|
||||
|
@ -2461,6 +2399,9 @@ void rigCommander::parseRegisters1A()
|
|||
// band stacking register
|
||||
parseBandStackReg();
|
||||
break;
|
||||
case '\x04':
|
||||
state.agc(payloadIn[02],AGC);
|
||||
break;
|
||||
case '\x06':
|
||||
// data mode
|
||||
// emit havedataMode( (bool) payloadIn[somebit])
|
||||
|
@ -2471,7 +2412,7 @@ void rigCommander::parseRegisters1A()
|
|||
// YY: filter selected, 01 through 03.;
|
||||
// if YY is 00 then XX was also set to 00
|
||||
emit haveDataMode((bool)payloadIn[03]);
|
||||
rigState.datamode = (bool)payloadIn[03];
|
||||
state.datamode((bool)payloadIn[03],NONE);
|
||||
break;
|
||||
case '\x07':
|
||||
// IP+ status
|
||||
|
@ -2493,32 +2434,24 @@ void rigCommander::parseRegister1B()
|
|||
// "Repeater tone"
|
||||
tone = decodeTone(payloadIn);
|
||||
emit haveTone(tone);
|
||||
rigState.mutex->lock();
|
||||
rigState.ctcss = tone;
|
||||
rigState.mutex->unlock();
|
||||
state.ctcss(tone,NONE);
|
||||
break;
|
||||
case '\x01':
|
||||
// "TSQL tone"
|
||||
tone = decodeTone(payloadIn);
|
||||
emit haveTSQL(tone);
|
||||
rigState.mutex->lock();
|
||||
rigState.tsql = tone;
|
||||
rigState.mutex->unlock();
|
||||
state.tsql(tone,NONE);
|
||||
break;
|
||||
case '\x02':
|
||||
// DTCS (DCS)
|
||||
tone = decodeTone(payloadIn, tinv, rinv);
|
||||
emit haveDTCS(tone, tinv, rinv);
|
||||
rigState.mutex->lock();
|
||||
rigState.dtcs = tone;
|
||||
rigState.mutex->unlock();
|
||||
state.dtcs(tone,NONE);
|
||||
break;
|
||||
case '\x07':
|
||||
// "CSQL code (DV mode)"
|
||||
tone = decodeTone(payloadIn);
|
||||
rigState.mutex->lock();
|
||||
rigState.csql = tone;
|
||||
rigState.mutex->unlock();
|
||||
state.csql(tone,NONE);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
@ -2539,9 +2472,49 @@ void rigCommander::parseRegister16()
|
|||
case '\x02':
|
||||
// Preamp
|
||||
emit havePreamp((unsigned char)payloadIn.at(2));
|
||||
rigState.mutex->lock();
|
||||
rigState.preamp = (unsigned char)payloadIn.at(2);
|
||||
rigState.mutex->unlock();
|
||||
state.preamp((unsigned char)payloadIn.at(2),NONE);
|
||||
break;
|
||||
case '\x22':
|
||||
state.nbFunc((bool)payloadIn.at(2), NONE);
|
||||
break;
|
||||
case '\x40':
|
||||
state.nrFunc((bool)payloadIn.at(2), NONE);
|
||||
break;
|
||||
case '\x41': // Auto notch
|
||||
state.anfFunc((bool)payloadIn.at(2), NONE);
|
||||
break;
|
||||
case '\x42':
|
||||
state.toneFunc((bool)payloadIn.at(2), NONE);
|
||||
break;
|
||||
case '\x43':
|
||||
state.tsqlFunc((bool)payloadIn.at(2), NONE);
|
||||
break;
|
||||
case '\44':
|
||||
state.compFunc((bool)payloadIn.at(2), NONE);
|
||||
break;
|
||||
case '\45':
|
||||
state.monFunc((bool)payloadIn.at(2), NONE);
|
||||
break;
|
||||
case '\46':
|
||||
state.voxFunc((bool)payloadIn.at(2), NONE);
|
||||
break;
|
||||
case '\x47':
|
||||
if (payloadIn.at(2) == '\00') {
|
||||
state.fbkinFunc(false, NONE);
|
||||
state.sbkinFunc(false, NONE);
|
||||
}
|
||||
else if (payloadIn.at(2) == '\01') {
|
||||
state.fbkinFunc(false, NONE);
|
||||
state.sbkinFunc(true, NONE);
|
||||
|
||||
}
|
||||
else if (payloadIn.at(2) == '\02') {
|
||||
state.fbkinFunc(true, NONE);
|
||||
state.sbkinFunc(false, NONE);
|
||||
}
|
||||
break;
|
||||
case '\48': // Manual Notch
|
||||
state.mnFunc((bool)payloadIn.at(2), NONE);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
@ -3815,49 +3788,51 @@ void rigCommander::parseFrequency()
|
|||
|
||||
// printHex(payloadIn, false, true);
|
||||
frequencyMhz = 0.0;
|
||||
if(payloadIn.length() == 7)
|
||||
if (payloadIn.length() == 7)
|
||||
{
|
||||
// 7300 has these digits too, as zeros.
|
||||
// IC-705 or IC-9700 with higher frequency data available.
|
||||
frequencyMhz += 100*(payloadIn[05] & 0x0f);
|
||||
frequencyMhz += (1000*((payloadIn[05] & 0xf0) >> 4));
|
||||
frequencyMhz += 100 * (payloadIn[05] & 0x0f);
|
||||
frequencyMhz += (1000 * ((payloadIn[05] & 0xf0) >> 4));
|
||||
|
||||
freq.Hz += (payloadIn[05] & 0x0f) * 1E6 * 100;
|
||||
freq.Hz += ((payloadIn[05] & 0xf0) >> 4) * 1E6 * 1000;
|
||||
freq.Hz += (payloadIn[05] & 0x0f) * 1E6 * 100;
|
||||
freq.Hz += ((payloadIn[05] & 0xf0) >> 4) * 1E6 * 1000;
|
||||
|
||||
}
|
||||
|
||||
freq.Hz += (payloadIn[04] & 0x0f) * 1E6;
|
||||
freq.Hz += ((payloadIn[04] & 0xf0) >> 4) * 1E6 * 10;
|
||||
freq.Hz += ((payloadIn[04] & 0xf0) >> 4) * 1E6 * 10;
|
||||
|
||||
frequencyMhz += payloadIn[04] & 0x0f;
|
||||
frequencyMhz += 10*((payloadIn[04] & 0xf0) >> 4);
|
||||
frequencyMhz += 10 * ((payloadIn[04] & 0xf0) >> 4);
|
||||
|
||||
// KHz land:
|
||||
frequencyMhz += ((payloadIn[03] & 0xf0) >>4)/10.0 ;
|
||||
frequencyMhz += ((payloadIn[03] & 0xf0) >> 4) / 10.0;
|
||||
frequencyMhz += (payloadIn[03] & 0x0f) / 100.0;
|
||||
|
||||
frequencyMhz += ((payloadIn[02] & 0xf0) >> 4) / 1000.0;
|
||||
frequencyMhz += (payloadIn[02] & 0x0f) / 10000.0;
|
||||
|
||||
frequencyMhz += ((payloadIn[01] & 0xf0) >> 4) / 100000.0;
|
||||
frequencyMhz += (payloadIn[01] & 0x0f) / 1000000.0;
|
||||
frequencyMhz += ((payloadIn[01] & 0xf0) >> 4) / 100000.0;
|
||||
frequencyMhz += (payloadIn[01] & 0x0f) / 1000000.0;
|
||||
|
||||
freq.Hz += payloadIn[01] & 0x0f;
|
||||
freq.Hz += ((payloadIn[01] & 0xf0) >> 4)* 10;
|
||||
freq.Hz += ((payloadIn[01] & 0xf0) >> 4) * 10;
|
||||
|
||||
freq.Hz += (payloadIn[02] & 0x0f) * 100;
|
||||
freq.Hz += ((payloadIn[02] & 0xf0) >> 4) * 1000;
|
||||
freq.Hz += (payloadIn[02] & 0x0f) * 100;
|
||||
freq.Hz += ((payloadIn[02] & 0xf0) >> 4) * 1000;
|
||||
|
||||
freq.Hz += (payloadIn[03] & 0x0f) * 10000;
|
||||
freq.Hz += ((payloadIn[03] & 0xf0) >>4) * 100000;
|
||||
freq.Hz += (payloadIn[03] & 0x0f) * 10000;
|
||||
freq.Hz += ((payloadIn[03] & 0xf0) >> 4) * 100000;
|
||||
|
||||
freq.MHzDouble = frequencyMhz;
|
||||
|
||||
rigState.mutex->lock();
|
||||
rigState.vfoAFreq = freq;
|
||||
rigState.mutex->unlock();
|
||||
|
||||
if (state.currentVfo() == 0) {
|
||||
state.vfoAFreq(freq.Hz, NONE);
|
||||
}
|
||||
else {
|
||||
state.vfoBFreq(freq.Hz, NONE);
|
||||
}
|
||||
emit haveFrequency(freq);
|
||||
}
|
||||
|
||||
|
@ -3935,11 +3910,9 @@ void rigCommander::parseMode()
|
|||
} else {
|
||||
filter = 0;
|
||||
}
|
||||
rigState.mutex->lock();
|
||||
rigState.mode = (unsigned char)payloadIn[01];
|
||||
rigState.filter = filter;
|
||||
rigState.mutex->unlock();
|
||||
emit haveMode((unsigned char)payloadIn[01], filter);
|
||||
state.mode((unsigned char)payloadIn[01],NONE);
|
||||
state.filter(filter,NONE);
|
||||
}
|
||||
|
||||
|
||||
|
@ -4014,6 +3987,144 @@ void rigCommander::setAntenna(unsigned char ant, bool rx)
|
|||
prepDataAndSend(payload);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
void rigCommander::getRigID()
|
||||
{
|
||||
QByteArray payload;
|
||||
|
@ -4086,7 +4197,185 @@ QByteArray rigCommander::stripData(const QByteArray &data, unsigned char cutPosi
|
|||
|
||||
void rigCommander::sendState()
|
||||
{
|
||||
emit stateInfo(&rigState);
|
||||
emit stateInfo(&state);
|
||||
}
|
||||
|
||||
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.
|
||||
/*
|
||||
FAGCFUNC, NBFUNC, COMPFUNC, VOXFUNC, TONEFUNC, TSQLFUNC, SBKINFUNC, FBKINFUNC, ANFFUNC, NRFUNC, AIPFUNC, APFFUNC, MONFUNC, MNFUNC,RFFUNC,
|
||||
AROFUNC, MUTEFUNC, VSCFUNC, REVFUNC, SQLFUNC, ABMFUNC, BCFUNC, MBCFUNC, RITFUNC, AFCFUNC, SATMODEFUNC, SCOPEFUNC,
|
||||
RESUMEFUNC, TBURSTFUNC, TUNERFUNC};
|
||||
*/
|
||||
|
||||
/* VFOAFREQ, VFOBFREQ, CURRENTVFO, PTT, MODE, FILTER, DUPLEX, DATAMODE, ANTENNA, RXANTENNA, CTCSS, TSQL, DTCS, CSQL */
|
||||
|
||||
if ((state.updated()) & (1ULL <<(VFOAFREQ))) {
|
||||
// VFO A FREQUENCY IS UPDATED!
|
||||
freqt freq;
|
||||
freq.Hz = state.vfoAFreq();
|
||||
setFrequency(0, freq);
|
||||
setFrequency(0, freq);
|
||||
setFrequency(0, freq);
|
||||
getFrequency();
|
||||
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(VFOBFREQ))) {
|
||||
// VFO B FREQUENCY IS UPDATED!
|
||||
freqt freq;
|
||||
freq.Hz = state.vfoBFreq();
|
||||
setFrequency(1, freq);
|
||||
setFrequency(1, freq);
|
||||
setFrequency(1, freq);
|
||||
getFrequency();
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(CURRENTVFO))) {
|
||||
// Work on VFOB - how do we do this?
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(PTT))) {
|
||||
setPTT(state.ptt());
|
||||
setPTT(state.ptt());
|
||||
setPTT(state.ptt());
|
||||
getPTT();
|
||||
}
|
||||
if (((state.updated()) & (1ULL <<(MODE))) || ((state.updated()) & (1ULL <<(FILTER)))) {
|
||||
setMode(state.mode(),state.filter());
|
||||
getMode();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(DUPLEX))) {
|
||||
setDuplexMode(state.duplex());
|
||||
getDuplexMode();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(DATAMODE))) {
|
||||
setDataMode(state.datamode(), state.filter());
|
||||
getDataMode();
|
||||
}
|
||||
|
||||
if (((state.updated()) & (1ULL <<(ANTENNA))) || ((state.updated()) & (1ULL <<(RXANTENNA)))) {
|
||||
setAntenna(state.antenna(), state.rxAntenna());
|
||||
getAntenna();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(CTCSS))) {
|
||||
setTone(state.ctcss());
|
||||
getTone();
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(TSQL))) {
|
||||
setTSQL(state.tsql());
|
||||
getTSQL();
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(DTCS))) {
|
||||
setDTCS(state.dtcs(),false,false); // Not sure about this?
|
||||
getDTCS();
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(CSQL))) { // Not sure about this one?
|
||||
//setTone(state.ctcss());
|
||||
//getTone();
|
||||
}
|
||||
|
||||
/* PREAMP, ATTENUATOR, MODINPUT, AFGAIN, RFGAIN, SQUELCH, TXPOWER, MICGAIN, COMPLEVEL, MONITORLEVEL, VOXGAIN, ANTIVOXGAIN */
|
||||
if ((state.updated()) & (1ULL <<(PREAMP))) {
|
||||
setPreamp(state.preamp());
|
||||
getPreamp();
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(ATTENUATOR))) {
|
||||
setAttenuator(state.attenuator());
|
||||
getAttenuator();
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(MODINPUT))) {
|
||||
getModInputLevel(rigInput::inputLAN); // Need to fix this!
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(AFGAIN))) {
|
||||
setAfGain(state.afGain());
|
||||
getAfGain();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(RFGAIN))) {
|
||||
setRfGain(state.rfGain());
|
||||
getRfGain();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(SQUELCH))) {
|
||||
setSquelch(state.squelch());
|
||||
getSql();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(TXPOWER))) {
|
||||
setTxPower(state.txPower());
|
||||
getTxLevel();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(MICGAIN))) {
|
||||
setMicGain(state.micGain());
|
||||
getMicGain();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(COMPLEVEL))) {
|
||||
setCompLevel(state.compLevel());
|
||||
getCompLevel();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(MONITORLEVEL))) {
|
||||
setMonitorLevel(state.monitorLevel());
|
||||
getMonitorLevel();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(VOXGAIN))) {
|
||||
setVoxGain(state.voxGain());
|
||||
getVoxGain();
|
||||
}
|
||||
|
||||
if ((state.updated()) & (1ULL <<(ANTIVOXGAIN))) {
|
||||
setAntiVoxGain(state.antiVoxGain());
|
||||
getAntiVoxGain();
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(NBFUNC))) {
|
||||
setNb(state.nbFunc());
|
||||
getNb();
|
||||
}
|
||||
if ((state.updated()) & (1ULL << (NRFUNC))) {
|
||||
setNr(state.nrFunc());
|
||||
getNr();
|
||||
}
|
||||
if ((state.updated()) & (1ULL << (ANFFUNC))) {
|
||||
setAutoNotch(state.anfFunc());
|
||||
getAutoNotch();
|
||||
}
|
||||
if ((state.updated()) & (1ULL << (TONEFUNC))) {
|
||||
setToneEnabled(state.toneFunc());
|
||||
getToneEnabled();
|
||||
}
|
||||
if ((state.updated()) & (1ULL << (TSQLFUNC))) {
|
||||
setToneSql(state.tsqlFunc());
|
||||
getToneSql();
|
||||
}
|
||||
if ((state.updated()) & (1ULL << (COMPFUNC))) {
|
||||
setCompressor(state.compFunc());
|
||||
getCompressor();
|
||||
}
|
||||
if ((state.updated()) & (1ULL << (MONFUNC))) {
|
||||
setMonitor(state.monFunc());
|
||||
getMonitor();
|
||||
}
|
||||
if ((state.updated()) & (1ULL << (VOXFUNC))) {
|
||||
setVox(state.voxFunc());
|
||||
getVox();
|
||||
}
|
||||
if ((state.updated()) & (1ULL <<(FBKINFUNC))) {
|
||||
setBreakIn(state.sbkinFunc()<<1);
|
||||
getBreakIn();
|
||||
}
|
||||
if ((state.updated()) & (1ULL << (MNFUNC))) {
|
||||
setManualNotch(state.mnFunc());
|
||||
getManualNotch();
|
||||
}
|
||||
|
||||
state.updated(0);
|
||||
}
|
||||
|
||||
void rigCommander::getDebug()
|
||||
|
|
101
rigcommander.h
101
rigcommander.h
|
@ -2,10 +2,10 @@
|
|||
#define RIGCOMMANDER_H
|
||||
|
||||
#include <QObject>
|
||||
#include <QMutex>
|
||||
#include <QMutexLocker>
|
||||
#include <QDebug>
|
||||
|
||||
|
||||
#include "commhandler.h"
|
||||
#include "pttyhandler.h"
|
||||
#include "udphandler.h"
|
||||
|
@ -13,6 +13,8 @@
|
|||
#include "repeaterattributes.h"
|
||||
#include "freqmemory.h"
|
||||
|
||||
#include "rigstate.h"
|
||||
|
||||
// This file figures out what to send to the comm and also
|
||||
// parses returns into useful things.
|
||||
|
||||
|
@ -61,78 +63,6 @@ struct timekind {
|
|||
bool isMinus;
|
||||
};
|
||||
|
||||
struct rigStateStruct {
|
||||
QMutex *mutex;
|
||||
freqt vfoAFreq;
|
||||
freqt vfoBFreq;
|
||||
unsigned char currentVfo;
|
||||
bool ptt;
|
||||
unsigned char mode;
|
||||
unsigned char filter;
|
||||
duplexMode duplex;
|
||||
bool datamode;
|
||||
unsigned char antenna;
|
||||
bool rxAntenna;
|
||||
// Tones
|
||||
quint16 ctcss;
|
||||
quint16 tsql;
|
||||
quint16 dtcs;
|
||||
quint16 csql;
|
||||
// Levels
|
||||
unsigned char preamp;
|
||||
unsigned char attenuator;
|
||||
unsigned char modInput;
|
||||
unsigned char afGain;
|
||||
unsigned char rfGain;
|
||||
unsigned char squelch;
|
||||
unsigned char txPower;
|
||||
unsigned char micGain;
|
||||
unsigned char compLevel;
|
||||
unsigned char monitorLevel;
|
||||
unsigned char voxGain;
|
||||
unsigned char antiVoxGain;
|
||||
// Meters
|
||||
unsigned char sMeter;
|
||||
unsigned char powerMeter;
|
||||
unsigned char swrMeter;
|
||||
unsigned char alcMeter;
|
||||
unsigned char compMeter;
|
||||
unsigned char voltageMeter;
|
||||
unsigned char currentMeter;
|
||||
// Functions
|
||||
bool fagcFunc=false;
|
||||
bool nbFunc=false;
|
||||
bool compFunc=false;
|
||||
bool voxFunc = false;
|
||||
bool toneFunc = false;
|
||||
bool tsqlFunc = false;
|
||||
bool sbkinFunc = false;
|
||||
bool fbkinFunc = false;
|
||||
bool anfFunc = false;
|
||||
bool nrFunc = false;
|
||||
bool aipFunc = false;
|
||||
bool apfFunc = false;
|
||||
bool monFunc = false;
|
||||
bool mnFunc = false;
|
||||
bool rfFunc = false;
|
||||
bool aroFunc = false;
|
||||
bool muteFunc = false;
|
||||
bool vscFunc = false;
|
||||
bool revFunc = false;
|
||||
bool sqlFunc = false;
|
||||
bool abmFunc = false;
|
||||
bool bcFunc = false;
|
||||
bool mbcFunc = false;
|
||||
bool ritFunc = false;
|
||||
bool afcFunc = false;
|
||||
bool satmodeFunc = false;
|
||||
bool scopeFunc = false;
|
||||
bool resumeFunc = false;
|
||||
bool tburstFunc = false;
|
||||
bool tunerFunc = false;
|
||||
bool lockFunc = false;
|
||||
};
|
||||
|
||||
class rigCommander : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
|
@ -148,6 +78,7 @@ public slots:
|
|||
void commSetup(unsigned char rigCivAddr, QString rigSerialPort, quint32 rigBaudRate,QString vsp);
|
||||
void commSetup(unsigned char rigCivAddr, udpPreferences prefs, audioSetup rxSetup, audioSetup txSetup, QString vsp);
|
||||
void closeComm();
|
||||
void stateUpdated();
|
||||
|
||||
// Power:
|
||||
void powerOn();
|
||||
|
@ -199,6 +130,26 @@ public slots:
|
|||
void setAttenuator(unsigned char att);
|
||||
void setPreamp(unsigned char pre);
|
||||
void setAntenna(unsigned char ant, bool rx);
|
||||
void setNb(bool enabled);
|
||||
void getNb();
|
||||
void setNr(bool enabled);
|
||||
void getNr();
|
||||
void setAutoNotch(bool enabled);
|
||||
void getAutoNotch();
|
||||
void setToneEnabled(bool enabled);
|
||||
void getToneEnabled();
|
||||
void setToneSql(bool enabled);
|
||||
void getToneSql();
|
||||
void setCompressor(bool enabled);
|
||||
void getCompressor();
|
||||
void setMonitor(bool enabled);
|
||||
void getMonitor();
|
||||
void setVox(bool enabled);
|
||||
void getVox();
|
||||
void setBreakIn(unsigned char type);
|
||||
void getBreakIn();
|
||||
void setManualNotch(bool enabled);
|
||||
void getManualNotch();
|
||||
|
||||
// Repeater:
|
||||
void setDuplexMode(duplexMode dm);
|
||||
|
@ -406,7 +357,7 @@ signals:
|
|||
void haveAntenna(unsigned char ant,bool rx);
|
||||
|
||||
// Rig State
|
||||
void stateInfo(rigStateStruct* state);
|
||||
void stateInfo(rigstate* state);
|
||||
|
||||
// Housekeeping:
|
||||
void getMoreDebug();
|
||||
|
@ -480,7 +431,7 @@ private:
|
|||
|
||||
struct rigCapabilities rigCaps;
|
||||
|
||||
rigStateStruct rigState;
|
||||
rigstate state;
|
||||
|
||||
bool haveRigCaps;
|
||||
model_kind model;
|
||||
|
|
364
rigctld.cpp
364
rigctld.cpp
|
@ -61,7 +61,7 @@ rigCtlD::~rigCtlD()
|
|||
// emit setFrequency(0, freq);
|
||||
//}
|
||||
|
||||
void rigCtlD::receiveStateInfo(rigStateStruct* state)
|
||||
void rigCtlD::receiveStateInfo(rigstate* state)
|
||||
{
|
||||
qInfo("Setting rig state");
|
||||
rigState = state;
|
||||
|
@ -100,7 +100,7 @@ void rigCtlD::receiveRigCaps(rigCapabilities caps)
|
|||
this->rigCaps = caps;
|
||||
}
|
||||
|
||||
rigCtlClient::rigCtlClient(int socketId, rigCapabilities caps, rigStateStruct* state, rigCtlD* parent) : QObject(parent)
|
||||
rigCtlClient::rigCtlClient(int socketId, rigCapabilities caps, rigstate* state, rigCtlD* parent) : QObject(parent)
|
||||
{
|
||||
|
||||
commandBuffer.clear();
|
||||
|
@ -132,7 +132,7 @@ void rigCtlClient::socketReadyRead()
|
|||
bool setCommand = false;
|
||||
if (commandBuffer.endsWith('\n'))
|
||||
{
|
||||
qDebug(logRigCtlD()) << sessionId << "command received" << commandBuffer;
|
||||
//qDebug(logRigCtlD()) << sessionId << "command received" << commandBuffer;
|
||||
commandBuffer.chop(1); // Remove \n character
|
||||
if (commandBuffer.endsWith('\r'))
|
||||
{
|
||||
|
@ -175,7 +175,6 @@ void rigCtlClient::socketReadyRead()
|
|||
|
||||
QStringList command = commandBuffer.mid(num).split(" ");
|
||||
|
||||
QMutexLocker locker(rigState->mutex);
|
||||
|
||||
if (command[0] == 0xf0 || command[0] == "chk_vfo")
|
||||
{
|
||||
|
@ -183,7 +182,7 @@ void rigCtlClient::socketReadyRead()
|
|||
if (longReply) {
|
||||
resp.append(QString("ChkVFO: "));
|
||||
}
|
||||
resp.append(QString("%1").arg(rigState->currentVfo));
|
||||
resp.append(QString("%1").arg(rigState->currentVfo()));
|
||||
response.append(resp);
|
||||
}
|
||||
else if (command[0] == "dump_state")
|
||||
|
@ -276,11 +275,11 @@ void rigCtlClient::socketReadyRead()
|
|||
if (longReply) {
|
||||
resp.append(QString("Frequency: "));
|
||||
}
|
||||
if (rigState->currentVfo == 0) {
|
||||
resp.append(QString("%1").arg(rigState->vfoAFreq.Hz));
|
||||
if (rigState->currentVfo()==0) {
|
||||
resp.append(QString("%1").arg(rigState->vfoAFreq()));
|
||||
}
|
||||
else {
|
||||
resp.append(QString("%1").arg(rigState->vfoBFreq.Hz));
|
||||
resp.append(QString("%1").arg(rigState->vfoBFreq()));
|
||||
}
|
||||
response.append(resp);
|
||||
}
|
||||
|
@ -307,11 +306,12 @@ void rigCtlClient::socketReadyRead()
|
|||
if (ok) {
|
||||
freq.Hz = static_cast<int>(newFreq);
|
||||
qDebug(logRigCtlD()) << QString("Set frequency: %1 (%2)").arg(freq.Hz).arg(command[1]);
|
||||
emit parent->setFrequency(vfo, freq);
|
||||
emit parent->setFrequency(vfo, freq);
|
||||
emit parent->setFrequency(vfo, freq);
|
||||
emit parent->setFrequency(vfo, freq);
|
||||
emit parent->setFrequency(vfo, freq);
|
||||
if (vfo == 0) {
|
||||
rigState->vfoAFreq(freq.Hz, VFOAFREQ);
|
||||
}
|
||||
else {
|
||||
rigState->vfoAFreq(freq.Hz, VFOBFREQ);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (command[0] == "1" || command[0] == "dump_caps")
|
||||
|
@ -341,7 +341,7 @@ void rigCtlClient::socketReadyRead()
|
|||
if (longReply) {
|
||||
resp.append(QString("PTT: "));
|
||||
}
|
||||
resp.append(QString("%1").arg(rigState->ptt));
|
||||
resp.append(QString("%1").arg(rigState->ptt()));
|
||||
response.append(resp);
|
||||
}
|
||||
else
|
||||
|
@ -353,11 +353,7 @@ void rigCtlClient::socketReadyRead()
|
|||
{
|
||||
setCommand = true;
|
||||
if (rigCaps.hasPTTCommand) {
|
||||
emit parent->setPTT(bool(command[1].toInt()));
|
||||
emit parent->setPTT(bool(command[1].toInt()));
|
||||
emit parent->setPTT(bool(command[1].toInt()));
|
||||
emit parent->setPTT(bool(command[1].toInt()));
|
||||
emit parent->setPTT(bool(command[1].toInt()));
|
||||
rigState->ptt(bool(command[1].toInt()), PTT);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -371,7 +367,7 @@ void rigCtlClient::socketReadyRead()
|
|||
resp.append("VFO: ");
|
||||
}
|
||||
|
||||
if (rigState->currentVfo == 0) {
|
||||
if (rigState->currentVfo() == 0) {
|
||||
resp.append("VFOA");
|
||||
}
|
||||
else {
|
||||
|
@ -400,10 +396,10 @@ void rigCtlClient::socketReadyRead()
|
|||
else if (command[0] == "s" || command[0] == "get_split_vfo")
|
||||
{
|
||||
if (longReply) {
|
||||
response.append(QString("Split: %1").arg(rigState->duplex));
|
||||
response.append(QString("Split: %1").arg(rigState->duplex()));
|
||||
}
|
||||
else {
|
||||
response.append(QString("%1").arg(rigState->duplex));
|
||||
response.append(QString("%1").arg(rigState->duplex()));
|
||||
}
|
||||
|
||||
QString resp;
|
||||
|
@ -411,7 +407,7 @@ void rigCtlClient::socketReadyRead()
|
|||
resp.append("TX VFO: ");
|
||||
}
|
||||
|
||||
if (rigState->currentVfo == 0)
|
||||
if (rigState->currentVfo() == 0)
|
||||
{
|
||||
resp.append(QString("%1").arg("VFOB"));
|
||||
}
|
||||
|
@ -425,12 +421,10 @@ void rigCtlClient::socketReadyRead()
|
|||
setCommand = true;
|
||||
if (command[1] == "1")
|
||||
{
|
||||
emit parent->setDuplexMode(dmSplitOn);
|
||||
rigState->duplex = dmSplitOn;
|
||||
rigState->duplex(dmSplitOn, DUPLEX);
|
||||
}
|
||||
else {
|
||||
emit parent->setDuplexMode(dmSplitOff);
|
||||
rigState->duplex = dmSplitOff;
|
||||
rigState->duplex(dmSplitOff, DUPLEX);
|
||||
}
|
||||
}
|
||||
else if (command[0] == "\xf3" || command[0] == "get_vfo_info")
|
||||
|
@ -439,25 +433,25 @@ void rigCtlClient::socketReadyRead()
|
|||
//response.append(QString("set_vfo: %1").arg(command[1]));
|
||||
|
||||
if (command[1] == "VFOB") {
|
||||
response.append(QString("Freq: %1").arg(rigState->vfoBFreq.Hz));
|
||||
response.append(QString("Freq: %1").arg(rigState->vfoBFreq()));
|
||||
}
|
||||
else {
|
||||
response.append(QString("Freq: %1").arg(rigState->vfoAFreq.Hz));
|
||||
response.append(QString("Freq: %1").arg(rigState->vfoAFreq()));
|
||||
}
|
||||
response.append(QString("Mode: %1").arg(getMode(rigState->mode, rigState->datamode)));
|
||||
response.append(QString("Width: %1").arg(getFilter(rigState->mode, rigState->filter)));
|
||||
response.append(QString("Split: %1").arg(rigState->duplex));
|
||||
response.append(QString("Mode: %1").arg(getMode(rigState->mode(), rigState->datamode())));
|
||||
response.append(QString("Width: %1").arg(getFilter(rigState->mode(), rigState->filter())));
|
||||
response.append(QString("Split: %1").arg(rigState->duplex()));
|
||||
response.append(QString("SatMode: %1").arg(0)); // Need to get satmode
|
||||
}
|
||||
else {
|
||||
if (command[1] == "VFOB") {
|
||||
response.append(QString("%1").arg(rigState->vfoBFreq.Hz));
|
||||
response.append(QString("%1").arg(rigState->vfoBFreq()));
|
||||
}
|
||||
else {
|
||||
response.append(QString("%1").arg(rigState->vfoAFreq.Hz));
|
||||
response.append(QString("%1").arg(rigState->vfoAFreq()));
|
||||
}
|
||||
response.append(QString("%1").arg(getMode(rigState->mode, rigState->datamode)));
|
||||
response.append(QString("%1").arg(getFilter(rigState->mode, rigState->filter)));
|
||||
response.append(QString("%1").arg(getMode(rigState->mode(), rigState->datamode())));
|
||||
response.append(QString("%1").arg(getFilter(rigState->mode(), rigState->filter())));
|
||||
}
|
||||
}
|
||||
else if (command[0] == "i" || command[0] == "get_split_freq")
|
||||
|
@ -466,56 +460,51 @@ void rigCtlClient::socketReadyRead()
|
|||
if (longReply) {
|
||||
resp.append("TX VFO: ");
|
||||
}
|
||||
if (rigState->currentVfo == 0) {
|
||||
resp.append(QString("%1").arg(rigState->vfoBFreq.Hz));
|
||||
if (rigState->currentVfo() == 0) {
|
||||
resp.append(QString("%1").arg(rigState->vfoBFreq()));
|
||||
}
|
||||
else {
|
||||
resp.append(QString("%1").arg(rigState->vfoAFreq.Hz));
|
||||
resp.append(QString("%1").arg(rigState->vfoAFreq()));
|
||||
}
|
||||
response.append(resp);
|
||||
}
|
||||
else if (command.length() > 1 && (command[0] == "I" || command[0] == "set_split_freq"))
|
||||
{
|
||||
setCommand = true;
|
||||
freqt freq;
|
||||
bool ok = false;
|
||||
double newFreq = 0.0f;
|
||||
newFreq = command[1].toDouble(&ok);
|
||||
if (ok) {
|
||||
freq.Hz = static_cast<int>(newFreq);
|
||||
qDebug(logRigCtlD()) << QString("set_split_freq: %1 (%2)").arg(freq.Hz).arg(command[1]);
|
||||
emit parent->setFrequency(1, freq);
|
||||
emit parent->setFrequency(1, freq);
|
||||
emit parent->setFrequency(1, freq);
|
||||
emit parent->setFrequency(1, freq);
|
||||
emit parent->setFrequency(1, freq);
|
||||
qDebug(logRigCtlD()) << QString("set_split_freq: %1 (%2)").arg(newFreq).arg(command[1]);
|
||||
rigState->vfoBFreq(static_cast<int>(newFreq),VFOBFREQ);
|
||||
}
|
||||
}
|
||||
else if (command.length() > 2 && (command[0] == "X" || command[0] == "set_split_mode"))
|
||||
{
|
||||
setCommand = true;
|
||||
}
|
||||
else if (command.length() > 0 && (command[0] == "x" || command[0] == "get_split_mode"))
|
||||
{
|
||||
}
|
||||
|
||||
else if (command.length() > 0 && (command[0] == "x" || command[0] == "get_split_mode"))
|
||||
{
|
||||
if (longReply) {
|
||||
response.append(QString("TX Mode: %1").arg(getMode(rigState->mode, rigState->datamode)));
|
||||
response.append(QString("TX Passband: %1").arg(getFilter(rigState->mode, rigState->filter)));
|
||||
response.append(QString("TX Mode: %1").arg(getMode(rigState->mode(), rigState->datamode())));
|
||||
response.append(QString("TX Passband: %1").arg(getFilter(rigState->mode(), rigState->filter())));
|
||||
}
|
||||
else {
|
||||
response.append(QString("%1").arg(getMode(rigState->mode, rigState->datamode)));
|
||||
response.append(QString("%1").arg(getFilter(rigState->mode, rigState->filter)));
|
||||
response.append(QString("%1").arg(getMode(rigState->mode(), rigState->datamode())));
|
||||
response.append(QString("%1").arg(getFilter(rigState->mode(), rigState->filter())));
|
||||
}
|
||||
}
|
||||
|
||||
else if (command[0] == "m" || command[0] == "get_mode")
|
||||
{
|
||||
if (longReply) {
|
||||
response.append(QString("Mode: %1").arg(getMode(rigState->mode, rigState->datamode)));
|
||||
response.append(QString("Passband: %1").arg(getFilter(rigState->mode, rigState->filter)));
|
||||
response.append(QString("Mode: %1").arg(getMode(rigState->mode(), rigState->datamode())));
|
||||
response.append(QString("Passband: %1").arg(getFilter(rigState->mode(), rigState->filter())));
|
||||
}
|
||||
else {
|
||||
response.append(QString("%1").arg(getMode(rigState->mode, rigState->datamode)));
|
||||
response.append(QString("%1").arg(getFilter(rigState->mode, rigState->filter)));
|
||||
response.append(QString("%1").arg(getMode(rigState->mode(), rigState->datamode())));
|
||||
response.append(QString("%1").arg(getFilter(rigState->mode(), rigState->filter())));
|
||||
}
|
||||
}
|
||||
else if (command[0] == "M" || command[0] == "set_mode")
|
||||
|
@ -541,14 +530,13 @@ void rigCtlClient::socketReadyRead()
|
|||
else
|
||||
width = 1;
|
||||
|
||||
emit parent->setMode(getMode(mode), width);
|
||||
rigState->mode(getMode(mode), MODE);
|
||||
rigState->filter(width, FILTER);
|
||||
if (mode.mid(0, 3) == "PKT") {
|
||||
emit parent->setDataMode(true, width);
|
||||
emit parent->setDataMode(true, width);
|
||||
rigState->datamode(true, DATAMODE);
|
||||
}
|
||||
else {
|
||||
emit parent->setDataMode(false, width);
|
||||
emit parent->setDataMode(false, width);
|
||||
rigState->datamode(true, DATAMODE);
|
||||
}
|
||||
}
|
||||
else if (command[0] == "s" || command[0] == "get_split_vfo")
|
||||
|
@ -585,34 +573,35 @@ void rigCtlClient::socketReadyRead()
|
|||
if (longReply) {
|
||||
response.append(QString("AntCurr: %1").arg(getAntName((unsigned char)command[1].toInt())));
|
||||
response.append(QString("Option: %1").arg(0));
|
||||
response.append(QString("AntTx: %1").arg(getAntName(rigState->antenna)));
|
||||
response.append(QString("AntRx: %1").arg(getAntName(rigState->antenna)));
|
||||
response.append(QString("AntTx: %1").arg(getAntName(rigState->antenna())));
|
||||
response.append(QString("AntRx: %1").arg(getAntName(rigState->antenna())));
|
||||
}
|
||||
else {
|
||||
response.append(QString("%1").arg(getAntName((unsigned char)command[1].toInt())));
|
||||
response.append(QString("%1").arg(0));
|
||||
response.append(QString("%1").arg(getAntName(rigState->antenna)));
|
||||
response.append(QString("%1").arg(getAntName(rigState->antenna)));
|
||||
response.append(QString("%1").arg(getAntName(rigState->antenna())));
|
||||
response.append(QString("%1").arg(getAntName(rigState->antenna())));
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (command[0] == "Y" || command[0] == "set_ant")
|
||||
{
|
||||
qInfo(logRigCtlD()) << "set_ant:";
|
||||
setCommand = true;
|
||||
setCommand = true;
|
||||
qInfo(logRigCtlD()) << "set_ant:" << command[1];
|
||||
rigState->antenna(antFromName(command[1]),ANTENNA);
|
||||
}
|
||||
else if (command[0] == "z" || command[0] == "get_xit")
|
||||
{
|
||||
QString resp;
|
||||
if (longReply) {
|
||||
resp.append("XIT: ");
|
||||
}
|
||||
resp.append(QString("%1").arg(0));
|
||||
response.append(resp);
|
||||
QString resp;
|
||||
if (longReply) {
|
||||
resp.append("XIT: ");
|
||||
}
|
||||
resp.append(QString("%1").arg(0));
|
||||
response.append(resp);
|
||||
}
|
||||
else if (command[0] == "Z" || command[0] == "set_xit")
|
||||
{
|
||||
setCommand = true;
|
||||
setCommand = true;
|
||||
}
|
||||
else if (command.length() > 1 && (command[0] == "l" || command[0] == "get_level"))
|
||||
{
|
||||
|
@ -624,46 +613,46 @@ void rigCtlClient::socketReadyRead()
|
|||
|
||||
if (command[1] == "STRENGTH") {
|
||||
if (rigCaps.model == model7610)
|
||||
value = getCalibratedValue(rigState->sMeter, IC7610_STR_CAL);
|
||||
value = getCalibratedValue(rigState->sMeter(), IC7610_STR_CAL);
|
||||
else if (rigCaps.model == model7850)
|
||||
value = getCalibratedValue(rigState->sMeter, IC7850_STR_CAL);
|
||||
value = getCalibratedValue(rigState->sMeter(), IC7850_STR_CAL);
|
||||
else
|
||||
value = getCalibratedValue(rigState->sMeter, IC7300_STR_CAL);
|
||||
value = getCalibratedValue(rigState->sMeter(), IC7300_STR_CAL);
|
||||
//qInfo(logRigCtlD()) << "Calibration IN:" << rigState->sMeter << "OUT" << value;
|
||||
resp.append(QString("%1").arg(value));
|
||||
}
|
||||
else if (command[1] == "AF") {
|
||||
resp.append(QString("%1").arg((float)rigState->afGain / 255.0));
|
||||
resp.append(QString("%1").arg((float)rigState->afGain() / 255.0));
|
||||
}
|
||||
else if (command[1] == "RF") {
|
||||
resp.append(QString("%1").arg((float)rigState->rfGain / 255.0));
|
||||
resp.append(QString("%1").arg((float)rigState->rfGain() / 255.0));
|
||||
}
|
||||
else if (command[1] == "SQL") {
|
||||
resp.append(QString("%1").arg((float)rigState->squelch / 255.0));
|
||||
resp.append(QString("%1").arg((float)rigState->squelch() / 255.0));
|
||||
}
|
||||
else if (command[1] == "COMP") {
|
||||
resp.append(QString("%1").arg((float)rigState->compLevel / 255.0));
|
||||
resp.append(QString("%1").arg((float)rigState->compLevel() / 255.0));
|
||||
}
|
||||
else if (command[1] == "MICGAIN") {
|
||||
resp.append(QString("%1").arg((float)rigState->micGain / 255.0));
|
||||
resp.append(QString("%1").arg((float)rigState->micGain() / 255.0));
|
||||
}
|
||||
else if (command[1] == "MON") {
|
||||
resp.append(QString("%1").arg((float)rigState->monitorLevel / 255.0));
|
||||
resp.append(QString("%1").arg((float)rigState->monitorLevel() / 255.0));
|
||||
}
|
||||
else if (command[1] == "VOXGAIN") {
|
||||
resp.append(QString("%1").arg((float)rigState->voxGain / 255.0));
|
||||
resp.append(QString("%1").arg((float)rigState->voxGain() / 255.0));
|
||||
}
|
||||
else if (command[1] == "ANTIVOX") {
|
||||
resp.append(QString("%1").arg((float)rigState->antiVoxGain / 255.0));
|
||||
resp.append(QString("%1").arg((float)rigState->antiVoxGain() / 255.0));
|
||||
}
|
||||
else if (command[1] == "RFPOWER") {
|
||||
resp.append(QString("%1").arg((float)rigState->txPower / 255.0));
|
||||
resp.append(QString("%1").arg((float)rigState->txPower() / 255.0));
|
||||
}
|
||||
else if (command[1] == "PREAMP") {
|
||||
resp.append(QString("%1").arg((float)rigState->preamp / 255.0));
|
||||
resp.append(QString("%1").arg(rigState->preamp()*10));
|
||||
}
|
||||
else if (command[1] == "ATT") {
|
||||
resp.append(QString("%1").arg((float)rigState->attenuator / 255.0));
|
||||
resp.append(QString("%1").arg(rigState->attenuator()));
|
||||
}
|
||||
else {
|
||||
resp.append(QString("%1").arg(value));
|
||||
|
@ -677,55 +666,49 @@ void rigCtlClient::socketReadyRead()
|
|||
setCommand = true;
|
||||
if (command[1] == "AF") {
|
||||
value = command[2].toFloat() * 255;
|
||||
emit parent->setAfGain(value);
|
||||
rigState->afGain = value;
|
||||
rigState->afGain(value,AFGAIN);
|
||||
}
|
||||
else if (command[1] == "RF") {
|
||||
value = command[2].toFloat() * 255;
|
||||
emit parent->setRfGain(value);
|
||||
rigState->rfGain = value;
|
||||
rigState->rfGain(value,RFGAIN);
|
||||
}
|
||||
else if (command[1] == "SQL") {
|
||||
value = command[2].toFloat() * 255;
|
||||
emit parent->setSql(value);
|
||||
rigState->squelch = value;
|
||||
rigState->squelch(value,SQUELCH);
|
||||
}
|
||||
else if (command[1] == "COMP") {
|
||||
value = command[2].toFloat() * 255;
|
||||
emit parent->setCompLevel(value);
|
||||
rigState->compLevel = value;
|
||||
rigState->compLevel(value,COMPLEVEL);
|
||||
}
|
||||
else if (command[1] == "MICGAIN") {
|
||||
value = command[2].toFloat() * 255;
|
||||
emit parent->setMicGain(value);
|
||||
rigState->micGain = value;
|
||||
rigState->micGain(value,MICGAIN);
|
||||
}
|
||||
else if (command[1] == "MON") {
|
||||
value = command[2].toFloat() * 255;
|
||||
emit parent->setMonitorLevel(value);
|
||||
rigState->monitorLevel = value;
|
||||
rigState->monitorLevel(value,MONITORLEVEL);
|
||||
}
|
||||
else if (command[1] == "VOXGAIN") {
|
||||
value = command[2].toFloat() * 255;
|
||||
emit parent->setVoxGain(value);
|
||||
rigState->voxGain = value;
|
||||
rigState->voxGain(value,VOXGAIN);
|
||||
}
|
||||
else if (command[1] == "ANTIVOX") {
|
||||
value = command[2].toFloat() * 255;
|
||||
emit parent->setAntiVoxGain(value);
|
||||
rigState->antiVoxGain = value;
|
||||
rigState->antiVoxGain(value,ANTIVOXGAIN);
|
||||
}
|
||||
else if (command[1] == "ATT") {
|
||||
value = command[2].toFloat();
|
||||
emit parent->setAttenuator(value);
|
||||
rigState->attenuator = value;
|
||||
rigState->attenuator(value,ATTENUATOR);
|
||||
}
|
||||
else if (command[1] == "PREAMP") {
|
||||
value = command[2].toFloat()/10;
|
||||
emit parent->setPreamp(value);
|
||||
rigState->preamp = value;
|
||||
value = command[2].toFloat() / 10;
|
||||
rigState->preamp(value, PREAMP);
|
||||
}
|
||||
|
||||
else if (command[1] == "AGC") {
|
||||
value = command[2].toInt();;
|
||||
rigState->agc(value, AGC);
|
||||
}
|
||||
|
||||
qInfo(logRigCtlD()) << "Setting:" << command[1] << command[2] << value;
|
||||
|
||||
}
|
||||
|
@ -739,265 +722,266 @@ void rigCtlClient::socketReadyRead()
|
|||
|
||||
if (command[1] == "FAGC")
|
||||
{
|
||||
result=rigState->fagcFunc;
|
||||
result=rigState->fagcFunc();
|
||||
}
|
||||
else if (command[1] == "NB")
|
||||
{
|
||||
result=rigState->nbFunc;
|
||||
result = rigState->nbFunc();
|
||||
}
|
||||
else if (command[1] == "COMP")
|
||||
{
|
||||
result=rigState->compFunc;
|
||||
result=rigState->compFunc();
|
||||
}
|
||||
else if (command[1] == "VOX")
|
||||
{
|
||||
result = rigState->voxFunc;
|
||||
result = rigState->voxFunc();
|
||||
}
|
||||
else if (command[1] == "TONE")
|
||||
{
|
||||
result = rigState->toneFunc;
|
||||
result = rigState->toneFunc();
|
||||
}
|
||||
else if (command[1] == "TSQL")
|
||||
{
|
||||
result = rigState->tsqlFunc;
|
||||
result = rigState->tsqlFunc();
|
||||
}
|
||||
else if (command[1] == "SBKIN")
|
||||
{
|
||||
result = rigState->sbkinFunc;
|
||||
result = rigState->sbkinFunc();
|
||||
}
|
||||
else if (command[1] == "FBKIN")
|
||||
{
|
||||
result = rigState->fbkinFunc;
|
||||
result = rigState->fbkinFunc();
|
||||
}
|
||||
else if (command[1] == "ANF")
|
||||
{
|
||||
result = rigState->anfFunc;
|
||||
result = rigState->anfFunc();
|
||||
}
|
||||
else if (command[1] == "NR")
|
||||
{
|
||||
result = rigState->nrFunc;
|
||||
result = rigState->nrFunc();
|
||||
}
|
||||
else if (command[1] == "AIP")
|
||||
{
|
||||
result = rigState->aipFunc;
|
||||
result = rigState->aipFunc();
|
||||
}
|
||||
else if (command[1] == "APF")
|
||||
{
|
||||
result = rigState->apfFunc;
|
||||
result = rigState->apfFunc();
|
||||
}
|
||||
else if (command[1] == "MON")
|
||||
{
|
||||
result = rigState->monFunc;
|
||||
result = rigState->monFunc();
|
||||
}
|
||||
else if (command[1] == "MN")
|
||||
{
|
||||
result = rigState->mnFunc;
|
||||
result = rigState->mnFunc();
|
||||
}
|
||||
else if (command[1] == "RF")
|
||||
{
|
||||
result = rigState->rfFunc;
|
||||
result = rigState->rfFunc();
|
||||
}
|
||||
else if (command[1] == "ARO")
|
||||
{
|
||||
result = rigState->aroFunc;
|
||||
result = rigState->aroFunc();
|
||||
}
|
||||
else if (command[1] == "MUTE")
|
||||
{
|
||||
result = rigState->muteFunc;
|
||||
result = rigState->muteFunc();
|
||||
}
|
||||
else if (command[1] == "VSC")
|
||||
{
|
||||
result = rigState->vscFunc;
|
||||
result = rigState->vscFunc();
|
||||
}
|
||||
else if (command[1] == "REV")
|
||||
{
|
||||
result = rigState->revFunc;
|
||||
result = rigState->revFunc();
|
||||
}
|
||||
else if (command[1] == "SQL")
|
||||
{
|
||||
result = rigState->sqlFunc;
|
||||
result = rigState->sqlFunc();
|
||||
}
|
||||
else if (command[1] == "ABM")
|
||||
{
|
||||
result = rigState->abmFunc;
|
||||
result = rigState->abmFunc();
|
||||
}
|
||||
else if (command[1] == "BC")
|
||||
{
|
||||
result = rigState->bcFunc;
|
||||
result = rigState->bcFunc();
|
||||
}
|
||||
else if (command[1] == "MBC")
|
||||
{
|
||||
result = rigState->mbcFunc;
|
||||
result = rigState->mbcFunc();
|
||||
}
|
||||
else if (command[1] == "RIT")
|
||||
{
|
||||
result = rigState->ritFunc;
|
||||
result = rigState->ritFunc();
|
||||
}
|
||||
else if (command[1] == "AFC")
|
||||
{
|
||||
result = rigState->afcFunc;
|
||||
result = rigState->afcFunc();
|
||||
}
|
||||
else if (command[1] == "SATMODE")
|
||||
{
|
||||
result = rigState->satmodeFunc;
|
||||
result = rigState->satmodeFunc();
|
||||
}
|
||||
else if (command[1] == "SCOPE")
|
||||
{
|
||||
result = rigState->scopeFunc;
|
||||
result = rigState->scopeFunc();
|
||||
}
|
||||
else if (command[1] == "RESUME")
|
||||
{
|
||||
result = rigState->resumeFunc;
|
||||
result = rigState->resumeFunc();
|
||||
}
|
||||
else if (command[1] == "TBURST")
|
||||
{
|
||||
result = rigState->tburstFunc;
|
||||
result = rigState->tburstFunc();
|
||||
}
|
||||
else if (command[1] == "TUNER")
|
||||
{
|
||||
result = rigState->tunerFunc;
|
||||
result = rigState->tunerFunc();
|
||||
}
|
||||
else if (command[1] == "LOCK")
|
||||
{
|
||||
result = rigState->lockFunc;
|
||||
result = rigState->lockFunc();
|
||||
}
|
||||
else {
|
||||
qInfo(logRigCtlD()) << "Unimplemented func:" << command[0] << command[1];
|
||||
}
|
||||
|
||||
resp.append(QString("%1").arg(result));
|
||||
response.append(resp);
|
||||
}
|
||||
else if (command.length() >2 && (command[0] == "U" || command[0] == "set_func"))
|
||||
{
|
||||
setCommand = true;
|
||||
|
||||
if (command[1] == "FAGC")
|
||||
{
|
||||
rigState->fagcFunc = (bool)command[2].toInt();
|
||||
rigState->fagcFunc((bool)command[2].toInt(),FAGCFUNC);
|
||||
}
|
||||
else if (command[1] == "NB")
|
||||
{
|
||||
rigState->nbFunc = (bool)command[2].toInt();
|
||||
rigState->nbFunc((bool)command[2].toInt(),NBFUNC);
|
||||
}
|
||||
else if (command[1] == "COMP")
|
||||
{
|
||||
rigState->compFunc = (bool)command[2].toInt();
|
||||
rigState->compFunc((bool)command[2].toInt(),COMPFUNC);
|
||||
}
|
||||
else if (command[1] == "VOX")
|
||||
{
|
||||
rigState->voxFunc = (bool)command[2].toInt();
|
||||
rigState->voxFunc((bool)command[2].toInt(),VOXFUNC);
|
||||
}
|
||||
else if (command[1] == "TONE")
|
||||
{
|
||||
rigState->toneFunc = (bool)command[2].toInt();
|
||||
rigState->toneFunc((bool)command[2].toInt(),TONEFUNC);
|
||||
}
|
||||
else if (command[1] == "TSQL")
|
||||
{
|
||||
rigState->tsqlFunc = (bool)command[2].toInt();
|
||||
rigState->tsqlFunc((bool)command[2].toInt(),TSQLFUNC);
|
||||
}
|
||||
else if (command[1] == "SBKIN")
|
||||
{
|
||||
rigState->sbkinFunc = (bool)command[2].toInt();
|
||||
rigState->sbkinFunc((bool)command[2].toInt(),SBKINFUNC);
|
||||
}
|
||||
else if (command[1] == "FBKIN")
|
||||
{
|
||||
rigState->fbkinFunc = (bool)command[2].toInt();
|
||||
rigState->fbkinFunc((bool)command[2].toInt(),FBKINFUNC);
|
||||
}
|
||||
else if (command[1] == "ANF")
|
||||
{
|
||||
rigState->anfFunc = (bool)command[2].toInt();
|
||||
rigState->anfFunc((bool)command[2].toInt(),ANFFUNC);
|
||||
}
|
||||
else if (command[1] == "NR")
|
||||
{
|
||||
rigState->nrFunc = (bool)command[2].toInt();
|
||||
rigState->nrFunc((bool)command[2].toInt(),NRFUNC);
|
||||
}
|
||||
else if (command[1] == "AIP")
|
||||
{
|
||||
rigState->aipFunc = (bool)command[2].toInt();
|
||||
rigState->aipFunc((bool)command[2].toInt(),AIPFUNC);
|
||||
}
|
||||
else if (command[1] == "APF")
|
||||
{
|
||||
rigState->apfFunc = (bool)command[2].toInt();
|
||||
rigState->apfFunc((bool)command[2].toInt(),APFFUNC);
|
||||
}
|
||||
else if (command[1] == "MON")
|
||||
{
|
||||
rigState->monFunc = (bool)command[2].toInt();
|
||||
rigState->monFunc((bool)command[2].toInt(),MONFUNC);
|
||||
}
|
||||
else if (command[1] == "MN")
|
||||
{
|
||||
rigState->mnFunc = (bool)command[2].toInt();
|
||||
rigState->mnFunc((bool)command[2].toInt(),MNFUNC);
|
||||
}
|
||||
else if (command[1] == "RF")
|
||||
{
|
||||
rigState->rfFunc = (bool)command[2].toInt();
|
||||
rigState->rfFunc((bool)command[2].toInt(),MONFUNC);
|
||||
}
|
||||
else if (command[1] == "ARO")
|
||||
{
|
||||
rigState->aroFunc = (bool)command[2].toInt();
|
||||
rigState->aroFunc((bool)command[2].toInt(),AROFUNC);
|
||||
}
|
||||
else if (command[1] == "MUTE")
|
||||
{
|
||||
rigState->muteFunc = (bool)command[2].toInt();
|
||||
rigState->muteFunc((bool)command[2].toInt(),MUTEFUNC);
|
||||
}
|
||||
else if (command[1] == "VSC")
|
||||
{
|
||||
rigState->vscFunc = (bool)command[2].toInt();
|
||||
rigState->vscFunc((bool)command[2].toInt(),VSCFUNC);
|
||||
}
|
||||
else if (command[1] == "REV")
|
||||
{
|
||||
rigState->revFunc = (bool)command[2].toInt();
|
||||
rigState->revFunc((bool)command[2].toInt(),REVFUNC);
|
||||
}
|
||||
else if (command[1] == "SQL")
|
||||
{
|
||||
rigState->sqlFunc = (bool)command[2].toInt();
|
||||
rigState->sqlFunc((bool)command[2].toInt(),SQLFUNC);
|
||||
}
|
||||
else if (command[1] == "ABM")
|
||||
{
|
||||
rigState->abmFunc = (bool)command[2].toInt();
|
||||
rigState->abmFunc((bool)command[2].toInt(),ABMFUNC);
|
||||
}
|
||||
else if (command[1] == "BC")
|
||||
{
|
||||
rigState->bcFunc = (bool)command[2].toInt();
|
||||
rigState->bcFunc((bool)command[2].toInt(),BCFUNC);
|
||||
}
|
||||
else if (command[1] == "MBC")
|
||||
{
|
||||
rigState->mbcFunc = (bool)command[2].toInt();
|
||||
rigState->mbcFunc((bool)command[2].toInt(),MBCFUNC);
|
||||
}
|
||||
else if (command[1] == "RIT")
|
||||
{
|
||||
rigState->ritFunc = (bool)command[2].toInt();
|
||||
rigState->ritFunc((bool)command[2].toInt(),RITFUNC);
|
||||
}
|
||||
else if (command[1] == "AFC")
|
||||
{
|
||||
rigState->afcFunc = (bool)command[2].toInt();
|
||||
rigState->afcFunc((bool)command[2].toInt(),AFCFUNC);
|
||||
}
|
||||
else if (command[1] == "SATMODE")
|
||||
{
|
||||
rigState->satmodeFunc = (bool)command[2].toInt();
|
||||
rigState->satmodeFunc((bool)command[2].toInt(),SATMODEFUNC);
|
||||
}
|
||||
else if (command[1] == "SCOPE")
|
||||
{
|
||||
rigState->scopeFunc = (bool)command[2].toInt();
|
||||
rigState->scopeFunc((bool)command[2].toInt(),SCOPEFUNC);
|
||||
}
|
||||
else if (command[1] == "RESUME")
|
||||
{
|
||||
rigState->resumeFunc = (bool)command[2].toInt();
|
||||
rigState->resumeFunc((bool)command[2].toInt(),RESUMEFUNC);
|
||||
}
|
||||
else if (command[1] == "TBURST")
|
||||
{
|
||||
rigState->tburstFunc = (bool)command[2].toInt();
|
||||
rigState->tburstFunc((bool)command[2].toInt(),TBURSTFUNC);
|
||||
}
|
||||
else if (command[1] == "TUNER")
|
||||
{
|
||||
rigState->tunerFunc = (bool)command[2].toInt();
|
||||
rigState->tunerFunc((bool)command[2].toInt(),TUNERFUNC);
|
||||
}
|
||||
else if (command[1] == "LOCK")
|
||||
{
|
||||
rigState->lockFunc = (bool)command[2].toInt();
|
||||
rigState->lockFunc((bool)command[2].toInt(),LOCKFUNC);
|
||||
}
|
||||
else {
|
||||
qInfo(logRigCtlD()) << "Unimplemented func:" << command[0] << command[1] << command[2];
|
||||
}
|
||||
|
||||
qInfo(logRigCtlD()) << "Setting:" << command[1] << command[2];
|
||||
}
|
||||
else if (command.length() > 1 && (command[0] == 0x88 || command[0] == "get_powerstat"))
|
||||
|
@ -1034,6 +1018,11 @@ void rigCtlClient::socketReadyRead()
|
|||
sendData(QString("%1: %2 %3 %4%5").arg(command[0]).arg(command[1]).arg(command[2]).arg(command[3]).arg(sep));
|
||||
}
|
||||
|
||||
if (setCommand)
|
||||
{
|
||||
emit parent->stateUpdated();
|
||||
}
|
||||
|
||||
if (setCommand || responseCode != 0 || longReply) {
|
||||
if (responseCode == 0) {
|
||||
response.append(QString("RPRT 0"));
|
||||
|
@ -1056,6 +1045,7 @@ void rigCtlClient::socketReadyRead()
|
|||
commandBuffer.clear();
|
||||
sep = " ";
|
||||
num = 0;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1073,7 +1063,7 @@ void rigCtlClient::closeSocket()
|
|||
|
||||
void rigCtlClient::sendData(QString data)
|
||||
{
|
||||
qDebug(logRigCtlD()) << "Sending:" << data;
|
||||
//qDebug(logRigCtlD()) << "Sending:" << data;
|
||||
if (socket != Q_NULLPTR && socket->isValid() && socket->isOpen())
|
||||
{
|
||||
socket->write(data.toLatin1());
|
||||
|
@ -1380,6 +1370,28 @@ QString rigCtlClient::getAntName(unsigned char ant)
|
|||
return ret;
|
||||
}
|
||||
|
||||
unsigned char rigCtlClient::antFromName(QString name) {
|
||||
unsigned char ret;
|
||||
|
||||
if (name == "ANT1")
|
||||
ret = 0;
|
||||
else if (name == "ANT2")
|
||||
ret = 1;
|
||||
else if (name == "ANT3")
|
||||
ret = 2;
|
||||
else if (name == "ANT4")
|
||||
ret = 3;
|
||||
else if (name == "ANT5")
|
||||
ret = 4;
|
||||
else if (name == "ANT_UNKNOWN")
|
||||
ret = 30;
|
||||
else if (name == "ANT_CURR")
|
||||
ret = 31;
|
||||
else
|
||||
ret = 99;
|
||||
return ret;
|
||||
}
|
||||
|
||||
int rigCtlClient::getCalibratedValue(unsigned char meter,cal_table_t cal) {
|
||||
|
||||
int interp;
|
||||
|
|
12
rigctld.h
12
rigctld.h
|
@ -19,6 +19,7 @@
|
|||
#include <typeindex>
|
||||
|
||||
#include "rigcommander.h"
|
||||
#include "rigstate.h"
|
||||
|
||||
#define CONSTANT_64BIT_FLAG(BIT) (1ull << (BIT))
|
||||
|
||||
|
@ -343,7 +344,7 @@ signals:
|
|||
void setVFO(unsigned char vfo);
|
||||
void setSplit(unsigned char split);
|
||||
void setDuplexMode(duplexMode dm);
|
||||
|
||||
void stateUpdated();
|
||||
// Power
|
||||
void sendPowerOn();
|
||||
void sendPowerOff();
|
||||
|
@ -368,11 +369,11 @@ signals:
|
|||
public slots:
|
||||
virtual void incomingConnection(qintptr socketDescriptor);
|
||||
void receiveRigCaps(rigCapabilities caps);
|
||||
void receiveStateInfo(rigStateStruct* state);
|
||||
void receiveStateInfo(rigstate* state);
|
||||
// void receiveFrequency(freqt freq);
|
||||
|
||||
private:
|
||||
rigStateStruct* rigState = Q_NULLPTR;
|
||||
rigstate* rigState = Q_NULLPTR;
|
||||
};
|
||||
|
||||
|
||||
|
@ -382,7 +383,7 @@ class rigCtlClient : public QObject
|
|||
|
||||
public:
|
||||
|
||||
explicit rigCtlClient(int socket, rigCapabilities caps, rigStateStruct *state, rigCtlD* parent = Q_NULLPTR);
|
||||
explicit rigCtlClient(int socket, rigCapabilities caps, rigstate *state, rigCtlD* parent = Q_NULLPTR);
|
||||
int getSocketId();
|
||||
|
||||
|
||||
|
@ -399,7 +400,7 @@ protected:
|
|||
|
||||
private:
|
||||
rigCapabilities rigCaps;
|
||||
rigStateStruct* rigState = Q_NULLPTR;
|
||||
rigstate* rigState = Q_NULLPTR;
|
||||
rigCtlD* parent;
|
||||
QString getMode(unsigned char mode, bool datamode);
|
||||
unsigned char getMode(QString modeString);
|
||||
|
@ -408,6 +409,7 @@ private:
|
|||
unsigned char getAntennas();
|
||||
quint64 getRadioModes();
|
||||
QString getAntName(unsigned char ant);
|
||||
unsigned char antFromName(QString name);
|
||||
int getCalibratedValue(unsigned char meter,cal_table_t cal);
|
||||
};
|
||||
|
||||
|
|
|
@ -0,0 +1,264 @@
|
|||
#ifndef RIGSTATE_H
|
||||
#define RIGSTATE_H
|
||||
|
||||
#include <QObject>
|
||||
#include <QMutex>
|
||||
|
||||
#include "rigcommander.h"
|
||||
|
||||
// Meters at the end as they are ALWAYS updated from the rig!
|
||||
enum stateTypes { NONE, VFOAFREQ, VFOBFREQ, CURRENTVFO, PTT, MODE, FILTER, DUPLEX, DATAMODE, ANTENNA, RXANTENNA, CTCSS, TSQL, DTCS, CSQL,
|
||||
PREAMP, AGC, ATTENUATOR, MODINPUT, AFGAIN, RFGAIN, SQUELCH, TXPOWER, MICGAIN, COMPLEVEL, MONITORLEVEL, VOXGAIN, ANTIVOXGAIN,
|
||||
FAGCFUNC, NBFUNC, COMPFUNC, VOXFUNC, TONEFUNC, TSQLFUNC, SBKINFUNC, FBKINFUNC, ANFFUNC, NRFUNC, AIPFUNC, APFFUNC, MONFUNC, MNFUNC,RFFUNC,
|
||||
AROFUNC, MUTEFUNC, VSCFUNC, REVFUNC, SQLFUNC, ABMFUNC, BCFUNC, MBCFUNC, RITFUNC, AFCFUNC, SATMODEFUNC, SCOPEFUNC,
|
||||
RESUMEFUNC, TBURSTFUNC, TUNERFUNC, LOCKFUNC, SMETER, POWERMETER, SWRMETER, ALCMETER, COMPMETER, VOLTAGEMETER, CURRENTMETER };
|
||||
|
||||
|
||||
class rigstate
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
void lock() { _mutex.lock(); return; }
|
||||
void unlock() { _mutex.unlock(); return; }
|
||||
|
||||
quint64 updated() { return _updated; }
|
||||
void updated(int update) { _mutex.lock(); _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
quint64 vfoAFreq() { return _vfoAFreq; }
|
||||
void vfoAFreq(quint64 vfoAFreq, int update) { _mutex.lock(); _vfoAFreq = vfoAFreq; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
quint64 vfoBFreq() { return _vfoBFreq; }
|
||||
void vfoBFreq(quint64 vfoBFreq, int update) { _mutex.lock(); _vfoBFreq = vfoBFreq; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
unsigned char currentVfo() { return _currentVfo; }
|
||||
void currentVfo(unsigned char currentVfo, int update) { _mutex.lock(); _currentVfo = currentVfo; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
bool ptt() { return _ptt; }
|
||||
void ptt(bool ptt, int update) { _mutex.lock(); _ptt = ptt; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
unsigned char mode() { return _mode; }
|
||||
void mode(unsigned char mode, int update) { _mutex.lock(); _mode = mode; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
unsigned char filter() { return _filter; }
|
||||
void filter(unsigned char filter, int update) { _mutex.lock(); _filter = filter; _updated |= 1ULL << update; _mutex.unlock();}
|
||||
|
||||
duplexMode duplex() { return _duplex; }
|
||||
void duplex(duplexMode duplex, int update) { _mutex.lock(); _duplex = duplex; _updated |= 1ULL << update; _mutex.unlock();}
|
||||
|
||||
bool datamode() { return _datamode; }
|
||||
void datamode(bool datamode, int update) { _mutex.lock(); _datamode = datamode; _updated |= 1ULL << update; _mutex.unlock();}
|
||||
|
||||
unsigned char antenna() { return _antenna; }
|
||||
void antenna(unsigned char antenna, int update) { _mutex.lock(); _antenna = antenna; _updated |= 1ULL << update; _mutex.unlock();}
|
||||
|
||||
bool rxAntenna() { return _rxAntenna; }
|
||||
void rxAntenna(bool rxAntenna, int update) { _mutex.lock(); _rxAntenna = rxAntenna; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
quint16 ctcss() { return _ctcss; }
|
||||
void ctcss(quint16 ctcss, int update) { _mutex.lock(); _ctcss = ctcss; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
quint16 tsql() { return _tsql; }
|
||||
void tsql(quint16 tsql, int update) { _mutex.lock(); _tsql = tsql; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
quint16 dtcs() { return _dtcs; }
|
||||
void dtcs(quint16 dtcs, int update) { _mutex.lock(); _dtcs = dtcs; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
quint16 csql() { return _csql; }
|
||||
void csql(quint16 csql, int update) { _mutex.lock(); _csql = csql; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
unsigned char preamp() { return _preamp; }
|
||||
void preamp(unsigned char preamp, int update) { _mutex.lock(); _preamp = preamp; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char agc() { return _agc; }
|
||||
void agc(unsigned char agc, int update) { _mutex.lock(); _agc = agc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char attenuator() { return _attenuator; }
|
||||
void attenuator(unsigned char attenuator, int update) { _mutex.lock(); _attenuator = attenuator; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char modInput() { return _modInput; }
|
||||
void modInput(unsigned char modInput, int update) { _mutex.lock(); _modInput = modInput; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char afGain() { return _afGain; }
|
||||
void afGain(unsigned char afGain, int update) { _mutex.lock(); _afGain = afGain; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char rfGain() { return _rfGain; }
|
||||
void rfGain(unsigned char rfGain, int update) { _mutex.lock(); _rfGain = rfGain; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char squelch() { return _squelch; }
|
||||
void squelch(unsigned char squelch, int update) { _mutex.lock(); _squelch = squelch; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char txPower() { return _txPower; }
|
||||
void txPower(unsigned char txPower, int update) { _mutex.lock(); _txPower = txPower; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char micGain() { return _micGain; }
|
||||
void micGain(unsigned char micGain, int update) { _mutex.lock(); _micGain = micGain; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char compLevel() { return _compLevel; }
|
||||
void compLevel(unsigned char compLevel, int update) { _mutex.lock(); _compLevel = compLevel; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char monitorLevel() { return _monitorLevel; }
|
||||
void monitorLevel(unsigned char monitorLevel, int update) { _mutex.lock(); _monitorLevel = monitorLevel; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char voxGain() { return _voxGain; }
|
||||
void voxGain(unsigned char voxGain, int update) { _mutex.lock(); _voxGain = voxGain; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char antiVoxGain() { return _antiVoxGain; }
|
||||
void antiVoxGain(unsigned char antiVoxGain, int update) { _mutex.lock(); _antiVoxGain = antiVoxGain; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char nbLevel() { return _nbLevel; }
|
||||
void nbLevel(unsigned char nbLevel, int update) { _mutex.lock(); _nbLevel = nbLevel; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char nbDepth() { return _nbDepth; }
|
||||
void nbDepth(unsigned char nbDepth, int update) { _mutex.lock(); _nbDepth = nbDepth; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char nbWidth() { return _nbWidth; }
|
||||
void nbWidth(unsigned char nbWidth, int update) { _mutex.lock(); _nbWidth = nbWidth; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char nrLevel() { return _nrLevel; }
|
||||
void nrLevel(unsigned char nrLevel, int update) { _mutex.lock(); _nrLevel = nrLevel; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
unsigned char sMeter() { return _sMeter; }
|
||||
void sMeter(unsigned char sMeter, int update) { _mutex.lock(); _sMeter = sMeter; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char powerMeter() { return _powerMeter; }
|
||||
void powerMeter(unsigned char powerMeter, int update) { _mutex.lock(); _powerMeter = powerMeter; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char swrMeter() { return _swrMeter; }
|
||||
void swrMeter(unsigned char swrMeter, int update) { _mutex.lock(); _swrMeter = swrMeter; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char alcMeter() { return _alcMeter; }
|
||||
void alcMeter(unsigned char alcMeter, int update) { _mutex.lock(); _alcMeter = alcMeter; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char compMeter() { return _compMeter; }
|
||||
void compMeter(unsigned char compMeter, int update) { _mutex.lock(); _compMeter = compMeter; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char voltageMeter() { return _voltageMeter; }
|
||||
void voltageMeter(unsigned char voltageMeter, int update) { _mutex.lock(); _voltageMeter = voltageMeter; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
unsigned char currentMeter() { return _currentMeter; }
|
||||
void currentMeter(unsigned char currentMeter, int update) { _mutex.lock(); _currentMeter = currentMeter; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
/*FAGCFUNC, NBFUNC, COMPFUNC, VOXFUNC, TONEFUNC, TSQLFUNC, SBKINFUNC, FBKINFUNC, ANFFUNC, NRFUNC, AIPFUNC, APFFUNC, MONFUNC, MNFUNC,RFFUNC,
|
||||
*/
|
||||
bool fagcFunc() { return _fagcFunc; }
|
||||
void fagcFunc(bool fagcFunc, int update) { _mutex.lock(); _fagcFunc = fagcFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool nbFunc() { return _nbFunc; }
|
||||
void nbFunc(bool nbFunc, int update) { _mutex.lock(); _nbFunc = nbFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool compFunc() { return _compFunc; }
|
||||
void compFunc(bool compFunc, int update) { _mutex.lock(); _compFunc = compFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool voxFunc() { return _voxFunc; }
|
||||
void voxFunc(bool voxFunc, int update) { _mutex.lock(); _voxFunc = voxFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool toneFunc() { return _toneFunc; }
|
||||
void toneFunc(bool toneFunc, int update) { _mutex.lock(); _toneFunc = toneFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool tsqlFunc() { return _tsqlFunc; }
|
||||
void tsqlFunc(bool tsqlFunc, int update) { _mutex.lock(); _tsqlFunc = tsqlFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool sbkinFunc() { return _sbkinFunc; }
|
||||
void sbkinFunc(bool sbkinFunc, int update) { _mutex.lock(); _sbkinFunc = sbkinFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool fbkinFunc() { return _fbkinFunc; }
|
||||
void fbkinFunc(bool fbkinFunc, int update) { _mutex.lock(); _fbkinFunc = fbkinFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool anfFunc() { return _anfFunc; }
|
||||
void anfFunc(bool anfFunc, int update) { _mutex.lock(); _anfFunc = anfFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool nrFunc() { return _nrFunc; }
|
||||
void nrFunc(bool nrFunc, int update) { _mutex.lock(); _nrFunc = nrFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool aipFunc() { return _aipFunc; }
|
||||
void aipFunc(bool aipFunc, int update) { _mutex.lock(); _aipFunc = aipFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool apfFunc() { return _apfFunc; }
|
||||
void apfFunc(bool apfFunc, int update) { _mutex.lock(); _apfFunc = apfFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool monFunc() { return _monFunc; }
|
||||
void monFunc(bool monFunc, int update) { _mutex.lock(); _monFunc = monFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool mnFunc() { return _mnFunc; }
|
||||
void mnFunc(bool mnFunc, int update) { _mutex.lock(); _mnFunc = mnFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool rfFunc() { return _rfFunc; }
|
||||
void rfFunc(bool rfFunc, int update) { _mutex.lock(); _rfFunc = rfFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
/* AROFUNC, MUTEFUNC, VSCFUNC, REVFUNC, SQLFUNC, ABMFUNC, BCFUNC, MBCFUNC, RITFUNC, AFCFUNC, SATMODEFUNC, SCOPEFUNC,
|
||||
RESUMEFUNC, TBURSTFUNC, TUNERFUNC}; */
|
||||
bool aroFunc() { return _aroFunc; }
|
||||
void aroFunc(bool aroFunc, int update) { _mutex.lock(); _aroFunc = aroFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool muteFunc() { return _muteFunc; }
|
||||
void muteFunc(bool muteFunc, int update) { _mutex.lock(); _muteFunc = muteFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool vscFunc() { return _vscFunc; }
|
||||
void vscFunc(bool vscFunc, int update) { _mutex.lock(); _vscFunc = vscFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool revFunc() { return _revFunc; }
|
||||
void revFunc(bool revFunc, int update) { _mutex.lock(); _revFunc = revFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool sqlFunc() { return _sqlFunc; }
|
||||
void sqlFunc(bool sqlFunc, int update) { _mutex.lock(); _sqlFunc = sqlFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool abmFunc() { return _abmFunc; }
|
||||
void abmFunc(bool abmFunc, int update) { _mutex.lock(); _abmFunc = abmFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool bcFunc() { return _bcFunc; }
|
||||
void bcFunc(bool bcFunc, int update) { _mutex.lock(); _bcFunc = bcFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool mbcFunc() { return _mbcFunc; }
|
||||
void mbcFunc(bool mbcFunc, int update) { _mutex.lock(); _mbcFunc = mbcFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool ritFunc() { return _ritFunc; }
|
||||
void ritFunc(bool ritFunc, int update) { _mutex.lock(); _ritFunc = ritFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool afcFunc() { return _afcFunc; }
|
||||
void afcFunc(bool afcFunc, int update) { _mutex.lock(); _afcFunc = afcFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool satmodeFunc() { return _satmodeFunc; }
|
||||
void satmodeFunc(bool satmodeFunc, int update) { _mutex.lock(); _satmodeFunc = satmodeFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool scopeFunc() { return _scopeFunc; }
|
||||
void scopeFunc(bool scopeFunc, int update) { _mutex.lock(); _scopeFunc = scopeFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool resumeFunc() { return _resumeFunc; }
|
||||
void resumeFunc(bool resumeFunc, int update) { _mutex.lock(); _resumeFunc = resumeFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool tburstFunc() { return _tburstFunc; }
|
||||
void tburstFunc(bool tburstFunc, int update) { _mutex.lock(); _tburstFunc = tburstFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool tunerFunc() { return _tunerFunc; }
|
||||
void tunerFunc(bool tunerFunc, int update) { _mutex.lock(); _tunerFunc = tunerFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
bool lockFunc() { return _lockFunc; }
|
||||
void lockFunc(bool lockFunc, int update) { _mutex.lock(); _lockFunc = lockFunc; _updated |= 1ULL << update; _mutex.unlock(); }
|
||||
|
||||
|
||||
private:
|
||||
QMutex _mutex;
|
||||
quint64 _updated=0;
|
||||
quint64 _vfoAFreq=0;
|
||||
quint64 _vfoBFreq=0;
|
||||
unsigned char _currentVfo=0;
|
||||
bool _ptt=0;
|
||||
unsigned char _mode=0;
|
||||
unsigned char _filter=0;
|
||||
duplexMode _duplex;
|
||||
bool _datamode=0;
|
||||
unsigned char _antenna=0;
|
||||
bool _rxAntenna=0;
|
||||
// Tones
|
||||
quint16 _ctcss;
|
||||
quint16 _tsql;
|
||||
quint16 _dtcs;
|
||||
quint16 _csql;
|
||||
// Levels
|
||||
unsigned char _preamp;
|
||||
unsigned char _agc;
|
||||
unsigned char _attenuator;
|
||||
unsigned char _modInput;
|
||||
unsigned char _afGain;
|
||||
unsigned char _rfGain;
|
||||
unsigned char _squelch;
|
||||
unsigned char _txPower;
|
||||
unsigned char _micGain;
|
||||
unsigned char _compLevel;
|
||||
unsigned char _monitorLevel;
|
||||
unsigned char _voxGain;
|
||||
unsigned char _antiVoxGain;
|
||||
unsigned char _nrLevel;
|
||||
unsigned char _nbLevel;
|
||||
unsigned char _nbDepth;
|
||||
unsigned char _nbWidth;
|
||||
// Meters
|
||||
unsigned char _sMeter;
|
||||
unsigned char _powerMeter;
|
||||
unsigned char _swrMeter;
|
||||
unsigned char _alcMeter;
|
||||
unsigned char _compMeter;
|
||||
unsigned char _voltageMeter;
|
||||
unsigned char _currentMeter;
|
||||
// Functions
|
||||
bool _fagcFunc = false;
|
||||
bool _nbFunc = false;
|
||||
bool _compFunc = false;
|
||||
bool _voxFunc = false;
|
||||
bool _toneFunc = false;
|
||||
bool _tsqlFunc = false;
|
||||
bool _sbkinFunc = false;
|
||||
bool _fbkinFunc = false;
|
||||
bool _anfFunc = false;
|
||||
bool _nrFunc = false;
|
||||
bool _aipFunc = false;
|
||||
bool _apfFunc = false;
|
||||
bool _monFunc = false;
|
||||
bool _mnFunc = false;
|
||||
bool _rfFunc = false;
|
||||
bool _aroFunc = false;
|
||||
bool _muteFunc = false;
|
||||
bool _vscFunc = false;
|
||||
bool _revFunc = false;
|
||||
bool _sqlFunc = false;
|
||||
bool _abmFunc = false;
|
||||
bool _bcFunc = false;
|
||||
bool _mbcFunc = false;
|
||||
bool _ritFunc = false;
|
||||
bool _afcFunc = false;
|
||||
bool _satmodeFunc = false;
|
||||
bool _scopeFunc = false;
|
||||
bool _resumeFunc = false;
|
||||
bool _tburstFunc = false;
|
||||
bool _tunerFunc = false;
|
||||
bool _lockFunc = false;
|
||||
|
||||
};
|
||||
|
||||
#endif
|
|
@ -46,6 +46,7 @@ wfmain::wfmain(const QString serialPortCL, const QString hostCL, const QString s
|
|||
qRegisterMetaType <audioSetup>();
|
||||
qRegisterMetaType <timekind>();
|
||||
qRegisterMetaType <datekind>();
|
||||
qRegisterMetaType<rigstate*>();
|
||||
|
||||
|
||||
haveRigCaps = false;
|
||||
|
@ -413,7 +414,7 @@ void wfmain::makeRig()
|
|||
connect(rig, SIGNAL(commReady()), this, SLOT(receiveCommReady()));
|
||||
|
||||
if (rigCtl != Q_NULLPTR) {
|
||||
connect(rig, SIGNAL(stateInfo(rigStateStruct*)), rigCtl, SLOT(receiveStateInfo(rigStateStruct*)));
|
||||
connect(rig, SIGNAL(stateInfo(rigstate*)), rigCtl, SLOT(receiveStateInfo(rigstate*)));
|
||||
connect(this, SIGNAL(requestRigState()), rig, SLOT(sendState()));
|
||||
connect(rigCtl, SIGNAL(setFrequency(unsigned char, freqt)), rig, SLOT(setFrequency(unsigned char, freqt)));
|
||||
connect(rigCtl, SIGNAL(setMode(unsigned char, unsigned char)), rig, SLOT(setMode(unsigned char, unsigned char)));
|
||||
|
@ -421,6 +422,7 @@ void wfmain::makeRig()
|
|||
connect(rigCtl, SIGNAL(setPTT(bool)), rig, SLOT(setPTT(bool)));
|
||||
connect(rigCtl, SIGNAL(sendPowerOn()), rig, SLOT(powerOn()));
|
||||
connect(rigCtl, SIGNAL(sendPowerOff()), rig, SLOT(powerOff()));
|
||||
connect(rigCtl, SIGNAL(stateUpdated()), rig, SLOT(stateUpdated()));
|
||||
|
||||
connect(rigCtl, SIGNAL(setAttenuator(unsigned char)), rig, SLOT(setAttenuator(unsigned char)));
|
||||
connect(rigCtl, SIGNAL(setPreamp(unsigned char)), rig, SLOT(setPreamp(unsigned char)));
|
||||
|
@ -5444,13 +5446,14 @@ void wfmain::on_enableRigctldChk_clicked(bool checked)
|
|||
connect(this, SIGNAL(sendRigCaps(rigCapabilities)), rigCtl, SLOT(receiveRigCaps(rigCapabilities)));
|
||||
if (rig != Q_NULLPTR) {
|
||||
// We are already connected to a rig.
|
||||
connect(rig, SIGNAL(stateInfo(rigStateStruct*)), rigCtl, SLOT(receiveStateInfo(rigStateStruct*)));
|
||||
connect(rig, SIGNAL(stateInfo(rigstate*)), rigCtl, SLOT(receiveStateInfo(rigstate*)));
|
||||
connect(rigCtl, SIGNAL(setFrequency(unsigned char, freqt)), rig, SLOT(setFrequency(unsigned char, freqt)));
|
||||
connect(rigCtl, SIGNAL(setMode(unsigned char, unsigned char)), rig, SLOT(setMode(unsigned char, unsigned char)));
|
||||
connect(rigCtl, SIGNAL(setDataMode(bool, unsigned char)), rig, SLOT(setDataMode(bool, unsigned char)));
|
||||
connect(rigCtl, SIGNAL(setPTT(bool)), rig, SLOT(setPTT(bool)));
|
||||
connect(rigCtl, SIGNAL(sendPowerOn()), rig, SLOT(powerOn()));
|
||||
connect(rigCtl, SIGNAL(sendPowerOff()), rig, SLOT(powerOff()));
|
||||
connect(rigCtl, SIGNAL(stateUpdated()), rig, SLOT(stateUpdated()));
|
||||
|
||||
connect(rigCtl, SIGNAL(setAttenuator(unsigned char)), rig, SLOT(setAttenuator(unsigned char)));
|
||||
connect(rigCtl, SIGNAL(setPreamp(unsigned char)), rig, SLOT(setPreamp(unsigned char)));
|
||||
|
|
3
wfmain.h
3
wfmain.h
|
@ -14,6 +14,7 @@
|
|||
#include "logcategories.h"
|
||||
#include "commhandler.h"
|
||||
#include "rigcommander.h"
|
||||
#include "rigstate.h"
|
||||
#include "freqmemory.h"
|
||||
#include "rigidentities.h"
|
||||
#include "repeaterattributes.h"
|
||||
|
@ -850,7 +851,6 @@ Q_DECLARE_METATYPE(struct rigCapabilities)
|
|||
Q_DECLARE_METATYPE(struct freqt)
|
||||
Q_DECLARE_METATYPE(struct mode_info)
|
||||
Q_DECLARE_METATYPE(struct udpPreferences)
|
||||
Q_DECLARE_METATYPE(struct rigStateStruct)
|
||||
Q_DECLARE_METATYPE(struct audioPacket)
|
||||
Q_DECLARE_METATYPE(struct audioSetup)
|
||||
Q_DECLARE_METATYPE(struct timekind)
|
||||
|
@ -858,6 +858,7 @@ Q_DECLARE_METATYPE(struct datekind)
|
|||
Q_DECLARE_METATYPE(enum rigInput)
|
||||
Q_DECLARE_METATYPE(enum meterKind)
|
||||
Q_DECLARE_METATYPE(enum spectrumMode)
|
||||
Q_DECLARE_METATYPE(rigstate*)
|
||||
|
||||
|
||||
#endif // WFMAIN_H
|
||||
|
|
Ładowanie…
Reference in New Issue