= my_rig->state.rx_range_list[i].startf && rigGet.freqMain <= my_rig->state.rx_range_list[i].endf) break;
+ }
+ if (rigGet.rangeListRxIndex != i) rigCmd.antList = 1;
+ rigGet.rangeListRxIndex = i;
+
+ rigCmd.rangeList = 0;
+ }
+
+ //* Antenna list
+ if (rigCmd.antList)
+ {
+ ui->comboBox_Ant->clear();
+ if (my_rig->state.tx_range_list[rigGet.rangeListRxIndex].ant == RIG_ANT_NONE) ui->comboBox_Ant->addItem("NONE"); //RIG_ANT_NONE
+ else for (i=0; i < RIG_ANT_MAX; i++)
+ {
+ if (my_rig->state.tx_range_list[rigGet.rangeListRxIndex].ant & (1UL << i))
+ {
+ switch (i)
+ {
+ case 0: ui->comboBox_Ant->addItem("ANT1"); break; //RIG_ANT_1
+ case 1: ui->comboBox_Ant->addItem("ANT2"); break; //RIG_ANT_2
+ case 2: ui->comboBox_Ant->addItem("ANT3"); break; //RIG_ANT_3
+ case 3: ui->comboBox_Ant->addItem("ANT4"); break; //RIG_ANT_4
+ case 4: ui->comboBox_Ant->addItem("ANT5"); break; //RIG_ANT_5
+ case 30: ui->comboBox_Ant->addItem("UNK"); break; //RIG_ANT_UNKNOWN
+ case 31: ui->comboBox_Ant->addItem("CURR"); break; //RIG_ANT_CURR
+ default: ui->comboBox_Ant->addItem("UNK"); break;
+ }
+ }
+ }
+ rigCmd.antList = 0;
+ }
+
+ //* Tone list
+ if (rigCmd.toneList)
+ {
+ ui->comboBox_toneFreq->clear();
+
+ if (rigGet.toneType == 2 || rigGet.toneType == 3)
+ {
+ for (i = 0; i < CTCSS_LIST_SIZE; i++) //CTCSS tone
+ {
+ if (my_rig->caps->ctcss_list[i] == 0) break;
+ ui->comboBox_toneFreq->addItem(QString::number(my_rig->caps->ctcss_list[i]/10.0,'f',1));
+ }
+ }
+
+ //for (i = 0; i < DCS_LIST_SIZE; i++) //DCS tone
+ //{
+ // if (my_rig->caps->dcs_list[i] == 0) break;
+ // ui->comboBox_toneFreq->addItem(QString::number(my_rig->caps->dcs_list[i]));
+ //}
+
+ rigCmd.toneList = 0;
+ }
+
+ //* RF
+ ui->radioButton_Tuner->setChecked(rigGet.tuner);
+ ui->comboBox_AGC->setCurrentText(rig_stragclevel(rigGet.agc));
+ ui->comboBox_Att->setCurrentText(QString::number(rigGet.att));
+ ui->comboBox_Preamp->setCurrentText(QString::number(rigGet.pre));
+
+ //* Split
+ if (rigGet.split == RIG_SPLIT_ON)
+ {
+ ui->pushButton_Split->setChecked(true);
+ if (rigGet.vfoSub == rigGet.vfoTx)
+ {
+ ui->label_vfoMainRxTx->setText("RX");
+ ui->label_vfoSubRxTx->setText("TX");
+ }
+ else
+ {
+ ui->label_vfoMainRxTx->setText("TX");
+ ui->label_vfoSubRxTx->setText("RX");
+ }
+ }
+ else
+ {
+ ui->pushButton_Split->setChecked(false);
+ ui->label_vfoMainRxTx->setText("RX TX");
+ ui->label_vfoSubRxTx->setText("");
+ }
+
+ //* PTT & Meter
+ if (rigGet.ptt == RIG_PTT_ON)
+ {
+ ui->pushButton_PTT->setChecked(true);
+ ui->label_vfoMain->setStyleSheet("QLabel {background-color: red}");
+
+ ui->progressBar_Smeter->setTx(true);
+ ui->progressBar_Smeter->setValue(rigGet.powerMeter.f*100);
+ ui->progressBar_subMeter->setValue(rigGet.subMeter.f);
+ }
+ else
+ {
+ ui->pushButton_PTT->setChecked(false);
+ ui->label_vfoMain->setStyleSheet("QLabel {}");
+
+ ui->progressBar_Smeter->setTx(false);
+ ui->progressBar_Smeter->setValue(rigGet.sMeter.i);
+ if (rigSet.meter == RIG_LEVEL_SWR) ui->progressBar_subMeter->setValue(1.0);
+ else ui->progressBar_subMeter->setValue(0.0);
+ }
+
+ //* Sliders
+ if (!ui->verticalSlider_RFpower->isSliderDown()) ui->verticalSlider_RFpower->setValue((int)(rigGet.rfPower*100));
+ if (!ui->verticalSlider_RFgain->isSliderDown()) ui->verticalSlider_RFgain->setValue((int)(rigGet.rfGain*100));
+ if (!ui->verticalSlider_AFGain->isSliderDown()) ui->verticalSlider_AFGain->setValue((int)(rigGet.afGain*100));
+ if (!ui->verticalSlider_Squelch->isSliderDown()) ui->verticalSlider_Squelch->setValue((int)(rigGet.squelch*100));
+
+ //* Filter
+ ui->checkBox_NB->setChecked(rigGet.noiseBlanker);
+ ui->checkBox_NR->setChecked(rigGet.noiseReduction);
+ ui->spinBox_NR->setValue(rigGet.noiseReductionLevel);
+ ui->checkBox_NF->setChecked(rigGet.notchFilter);
+
+ //* CW
+ ui->checkBox_BKIN->setChecked(rigGet.bkin);
+ ui->checkBox_APF->setChecked(rigGet.apf);
+ ui->spinBox_WPM->setValue(rigGet.wpm);
+
+ //* FM
+ if (rigGet.rptShift == RIG_RPT_SHIFT_MINUS) ui->radioButton_RPTshiftMinus->setChecked(true); //-
+ else if (rigGet.rptShift == RIG_RPT_SHIFT_PLUS) ui->radioButton_RPTshiftPlus->setChecked(true); //+
+ else ui->radioButton_RPTshiftSimplex->setChecked(true); //Simplex
+
+ ui->comboBox_toneType->setCurrentIndex(rigGet.toneType);
+ if (rigGet.toneType == 2 || rigGet.toneType ==3) ui->comboBox_toneFreq->setCurrentText(QString::number(rigGet.tone/10.0)); //CTCSS
+ else if (rigGet.toneType == 4 || rigGet.toneType ==5) ui->comboBox_toneFreq->setCurrentText(QString::number(rigGet.tone)); //DCS
+}
+
+
+//* RigDaemon handle results
+void MainWindow::on_rigDaemonResultReady()
+{
+ guiUpdate();
+}
+
+//* SubMeter
+void MainWindow::setSubMeter()
+{
+ if (rigSet.meter == RIG_LEVEL_SWR)
+ {
+ ui->progressBar_subMeter->setMeterSWR(true);
+ ui->progressBar_subMeter->setMaxValue(4.0);
+ ui->progressBar_subMeter->setGateValue(2.0);
+ ui->progressBar_subMeter->setLongStep(0.5);
+ ui->progressBar_subMeter->setShortStep(0.1);
+ ui->progressBar_subMeter->setValue(1.0);
+ }
+ else
+ {
+ ui->progressBar_subMeter->setMeterSWR(false);
+ ui->progressBar_subMeter->setMaxValue(1.0);
+ ui->progressBar_subMeter->setMinValue(0.0);
+ ui->progressBar_subMeter->setGateValue(0.5);
+ ui->progressBar_subMeter->setPrecision(1);
+ ui->progressBar_subMeter->setLongStep(0.5);
+ ui->progressBar_subMeter->setShortStep(0.1);
+ ui->progressBar_subMeter->setValue(0);
+ }
+}
+
+
+//***** PushButton *****
+
+void MainWindow::on_pushButton_Connect_toggled(bool checked)
+{
+ if (checked && rigCom.connected == 0)
+ {
+ retcode = rigDaemon->rigConnect(); //Open Rig connection
+
+ if (retcode != RIG_OK) //Connection error
+ {
+ rigCom.connected = 0;
+ ui->statusbar->showMessage(rigerror(retcode));
+ ui->pushButton_Connect->setChecked(false); //Uncheck the button
+ }
+ else //Rig connected
+ {
+ rigCom.connected = 1;
+ guiInit();
+ if (rigCap.onoff == 0 || rigGet.onoff == RIG_POWER_ON) timer->start(rigCom.rigRefresh);
+ }
+ }
+ else if (rigCom.connected) //Button unchecked
+ {
+ rigCom.connected = 0;
+ timer->stop();
+ rig_close(my_rig); //Close the communication to the rig
+ //rig_cleanup(my_rig); //Release rig handle and free associated memory
+ }
+}
+
+void MainWindow::on_pushButton_Power_toggled(bool checked)
+{
+ if (checked && !rigGet.onoff)
+ {
+ retcode = rig_set_powerstat(my_rig, RIG_POWER_ON);
+ if (retcode != RIG_OK)
+ {
+ ui->pushButton_Power->setChecked(false); //Uncheck the button
+ ui->statusbar->showMessage(rigerror(retcode));
+ }
+ else timer->start(rigCom.rigRefresh);
+ }
+ else if (!checked && rigGet.onoff)
+ {
+ retcode = rig_set_powerstat(my_rig, RIG_POWER_OFF);
+ if (retcode == RIG_OK)
+ {
+ ui->pushButton_Power->setChecked(false); //Uncheck the button
+ timer->stop();
+ }
+ }
+}
+
+void MainWindow::on_pushButton_PTT_toggled(bool checked)
+{
+ if (checked && !rigGet.ptt)
+ {
+ rigSet.ptt = RIG_PTT_ON;
+ rigCmd.ptt = 1;
+ }
+ else if (!checked && rigGet.ptt)
+ {
+ rigSet.ptt = RIG_PTT_OFF;
+ rigCmd.ptt = 1;
+ }
+}
+
+void MainWindow::on_pushButton_Split_toggled(bool checked)
+{
+ if (checked && !rigGet.split)
+ {
+ rigSet.split = RIG_SPLIT_ON;
+ rigCmd.split = 1;
+ }
+ else if (!checked && rigGet.split)
+ {
+ rigSet.split = RIG_SPLIT_OFF;
+ rigCmd.split = 1;
+ }
+}
+
+void MainWindow::on_pushButton_QSplit_clicked()
+{
+ quick_split();
+}
+
+void MainWindow::on_pushButton_AB_clicked()
+{
+ rigCmd.vfoXchange = 1;
+}
+
+void MainWindow::on_pushButton_AeqB_clicked()
+{
+ rigCmd.vfoCopy = 1;
+}
+
+void MainWindow::on_pushButton_Fast_toggled(bool checked)
+{
+ if (checked) fastDial = 1;
+ else fastDial = 0;
+}
+
+void MainWindow::on_pushButton_Tune_clicked()
+{
+ rigCmd.tune = 1;
+}
+
+void MainWindow::on_pushButton_Band160_clicked()
+{
+ set_band(160);
+}
+
+void MainWindow::on_pushButton_Band80_clicked()
+{
+ set_band(80);
+}
+
+void MainWindow::on_pushButton_Band60_clicked()
+{
+ set_band(60);
+}
+
+void MainWindow::on_pushButton_Band40_clicked()
+{
+ set_band(40);
+}
+
+void MainWindow::on_pushButton_Band30_clicked()
+{
+ set_band(30);
+}
+
+void MainWindow::on_pushButton_Band20_clicked()
+{
+ set_band(20);
+}
+
+void MainWindow::on_pushButton_Band17_clicked()
+{
+ set_band(17);
+}
+
+void MainWindow::on_pushButton_Band15_clicked()
+{
+ set_band(15);
+}
+
+void MainWindow::on_pushButton_Band12_clicked()
+{
+ set_band(12);
+}
+
+void MainWindow::on_pushButton_Band10_clicked()
+{
+ set_band(10);
+}
+
+void MainWindow::on_pushButton_Band6_clicked()
+{
+ set_band(6);
+}
+
+void MainWindow::on_pushButton_Band2_clicked()
+{
+ set_band(2);
+}
+
+void MainWindow::on_pushButton_Band70_clicked()
+{
+ set_band(70);
+}
+
+void MainWindow::on_pushButton_BandGen_clicked()
+{
+ set_band(1);
+}
+
+void MainWindow::on_pushButton_BandDown_clicked()
+{
+ rigCmd.bandDown = 1;
+}
+
+void MainWindow::on_pushButton_BandUp_clicked()
+{
+ rigCmd.bandUp = 1;
+}
+
+//***** CheckBox *****
+
+void MainWindow::on_checkBox_NAR_toggled(bool checked)
+{
+ if (checked && !rigGet.bwNarrow)
+ {
+ rigSet.bwidth = rig_passband_narrow(my_rig, rigGet.mode);
+ rigCmd.bwidth = 1;
+ }
+ else if (!checked && rigGet.bwNarrow)
+ {
+ rigSet.bwidth = RIG_PASSBAND_NORMAL;
+ rigCmd.bwidth = 1;
+ }
+}
+
+void MainWindow::on_checkBox_BKIN_toggled(bool checked)
+{
+ if (checked && !rigGet.bkin)
+ {
+ rigSet.bkin = 1;
+ rigCmd.bkin = 1;
+ }
+ else if (!checked && rigGet.bkin)
+ {
+ rigSet.bkin = 0;
+ rigCmd.bkin = 1;
+ }
+}
+
+void MainWindow::on_checkBox_NB_toggled(bool checked)
+{
+ if (checked && !rigGet.noiseBlanker)
+ {
+ rigSet.noiseBlanker = 1;
+ rigCmd.noiseBlanker = 1;
+ }
+ else if (!checked && rigGet.noiseBlanker)
+ {
+ rigSet.noiseBlanker = 0;
+ rigCmd.noiseBlanker = 1;
+ }
+}
+
+void MainWindow::on_checkBox_NR_toggled(bool checked)
+{
+ if (checked && !rigGet.noiseReduction)
+ {
+ rigSet.noiseReduction = 1;
+ rigCmd.noiseReduction = 1;
+ }
+ else if (!checked && rigGet.noiseReduction)
+ {
+ rigSet.noiseReduction = 0;
+ rigCmd.noiseReduction = 1;
+ }
+}
+
+void MainWindow::on_checkBox_NF_toggled(bool checked)
+{
+ if (checked && !rigGet.notchFilter)
+ {
+ rigSet.notchFilter = 1;
+ rigCmd.notchFilter = 1;
+ }
+ else if (!checked && rigGet.notchFilter)
+ {
+ rigSet.notchFilter = 0;
+ rigCmd.notchFilter = 1;
+ }
+}
+
+void MainWindow::on_checkBox_APF_toggled(bool checked)
+{
+ if (checked && !rigGet.apf)
+ {
+ rigSet.apf = 1;
+ rigCmd.apf = 1;
+ }
+ else if (!checked && rigGet.apf)
+ {
+ rigSet.apf = 0;
+ rigCmd.apf = 1;
+ }
+}
+
+
+//***** RadioButton *****
+
+void MainWindow::on_radioButton_Tuner_toggled(bool checked)
+{
+ if (checked && !rigGet.tuner)
+ {
+ rigSet.tuner = 1;
+ rigCmd.tuner = 1;
+ }
+ else if (!checked && rigGet.tuner)
+ {
+ rigSet.tuner = 0;
+ rigCmd.tuner = 1;
+ }
+}
+
+void MainWindow::on_radioButton_RPTshiftSimplex_toggled(bool checked)
+{
+ if (checked)
+ {
+ rigSet.rptShift = RIG_RPT_SHIFT_NONE;
+ rigCmd.rptShift = 1;
+ }
+}
+
+void MainWindow::on_radioButton_RPTshiftMinus_toggled(bool checked)
+{
+ if (checked)
+ {
+ rigSet.rptShift = RIG_RPT_SHIFT_MINUS;
+ rigCmd.rptShift = 1;
+ }
+}
+
+
+void MainWindow::on_radioButton_RPTshiftPlus_toggled(bool checked)
+{
+ if (checked)
+ {
+ rigSet.rptShift = RIG_RPT_SHIFT_PLUS;
+ rigCmd.rptShift = 1;
+ }
+}
+
+
+//***** Dial *****
+
+void MainWindow::on_dial_valueChanged(int value)
+{
+ int step;
+
+ step = value - prevDial;
+ if (step<=99 && step>50) step = value - 100 - prevDial;
+ if (step>=-99 && step<-50) step = value + 100 - prevDial;
+ prevDial = value;
+
+ if (ui->radioButton_VFOSub->isChecked()) //dial VFO Sub
+ {
+ rigSet.freqSub = rigGet.freqSub + step*(!fastDial*10+fastDial*100);
+ rigCmd.freqSub = 1;
+ }
+ else //dial VFO Main
+ {
+ rigSet.freqMain = rigGet.freqMain + step*(!fastDial*10+fastDial*100);
+ rigCmd.freqMain = 1;
+ }
+}
+
+void MainWindow::on_vfoDisplayValueChanged(int value)
+{
+ rigSet.freqMain = value;
+ rigCmd.freqMain = 1;
+}
+
+//***** ComboBox *****
+
+void MainWindow::on_comboBox_Mode_activated(int index)
+{
+ rigSet.mode = rig_parse_mode(ui->comboBox_Mode->itemText(index).toLatin1());
+ rigCmd.mode = 1;
+}
+
+void MainWindow::on_comboBox_ModeSub_activated(int index)
+{
+ rigSet.modeSub = rig_parse_mode(ui->comboBox_ModeSub->itemText(index).toLatin1());
+ rigCmd.modeSub = 1;
+}
+
+void MainWindow::on_comboBox_BW_activated(int index)
+{
+ rigSet.bwidth = ui->comboBox_BW->itemText(index).toInt();
+ rigCmd.bwidth = 1;
+}
+
+void MainWindow::on_comboBox_AGC_activated(int index)
+{
+ rigSet.agc = levelagcstr(ui->comboBox_AGC->itemText(index));
+ rigCmd.agc = 1;
+}
+
+void MainWindow::on_comboBox_Att_activated(int index)
+{
+ rigSet.att = ui->comboBox_Att->itemText(index).toInt();
+ rigCmd.att = 1;
+}
+
+void MainWindow::on_comboBox_Preamp_activated(int index)
+{
+ rigSet.pre = ui->comboBox_Preamp->itemText(index).toInt();
+ rigCmd.pre = 1;
+}
+
+void MainWindow::on_comboBox_Ant_activated(int index)
+{
+ rigSet.ant = antstr(ui->comboBox_Ant->itemText(index));
+ rigCmd.ant = 1;
+}
+
+void MainWindow::on_comboBox_Meter_activated(int index)
+{
+ rigSet.meter = levelmeterstr (ui->comboBox_Meter->itemText(index));
+ setSubMeter();
+}
+
+void MainWindow::on_comboBox_toneType_activated(int index)
+{
+ rigSet.toneType = index;
+ rigCmd.toneList = 1; //update tone list
+ rigCmd.tone = 1;
+}
+
+void MainWindow::on_comboBox_toneFreq_activated(int index)
+{
+ QString arg = ui->comboBox_toneFreq->itemText(index);
+ arg = arg.remove("."); //Remove '.' from CTCSS (as for hamlib CTCSS tone list)
+
+ if (rigGet.toneType == 2 || rigGet.toneType == 3) rigSet.tone = arg.toUInt();
+ rigCmd.tone = 1;
+}
+
+
+//***** Spin Box *****
+
+void MainWindow::on_spinBox_NR_valueChanged(int arg1)
+{
+ rigSet.noiseReductionLevel = arg1;
+ rigCmd.noiseReductionLevel = 1;
+}
+
+void MainWindow::on_spinBox_WPM_valueChanged(int arg1)
+{
+ rigSet.wpm = arg1;
+ rigCmd.wpm = 1;
+}
+
+
+//***** Slider *****
+
+void MainWindow::on_verticalSlider_RFpower_valueChanged(int value)
+{
+ if (!rigCmd.rfPower)
+ {
+ if (value < 5) value = 5;
+ rigSet.rfPower = (float)(value)/100;
+ if (rigSet.rfPower != rigGet.rfPower) rigCmd.rfPower = 1;
+ }
+}
+
+void MainWindow::on_verticalSlider_RFgain_valueChanged(int value)
+{
+ if (!rigCmd.rfGain)
+ {
+ rigSet.rfGain = (float)(value)/100;
+ if (rigSet.rfGain != rigGet.rfGain) rigCmd.rfGain = 1;
+ }
+}
+
+void MainWindow::on_verticalSlider_AFGain_valueChanged(int value)
+{
+ if (!rigCmd.afGain)
+ {
+ rigSet.afGain = (float)(value)/100;
+ if (rigSet.afGain != rigGet.afGain) rigCmd.afGain = 1;
+ }
+}
+
+
+void MainWindow::on_verticalSlider_Squelch_valueChanged(int value)
+{
+ if (!rigCmd.squelch)
+ {
+ rigSet.squelch = (float)(value)/100;
+ if (rigSet.squelch != rigGet.squelch) rigCmd.squelch = 1;
+ }
+}
+
+void MainWindow::on_horizontalSlider_IFshift_valueChanged(int value)
+{
+ if (!rigCmd.ifShift)
+ {
+ rigSet.ifShift = value;
+ if (rigSet.ifShift != rigGet.ifShift) rigCmd.ifShift = 1;
+ }
+}
+
+
+//***** Menu *****
+
+void MainWindow::on_action_Connection_triggered()
+{
+ DialogConfig config;
+ config.setModal(true);
+ config.exec();
+}
+
+void MainWindow::on_action_Setup_triggered()
+{
+ DialogSetup setup;
+ setup.setModal(true);
+ setup.exec();
+}
+
+void MainWindow::on_action_AboutCatRadio_triggered()
+{
+ QMessageBox msgBox;
+ msgBox.setWindowTitle("About");
+ msgBox.setTextFormat(Qt::RichText);
+ QString version = QString::number(VERSION_MAJ)+"."+QString::number(VERSION_MIN)+"."+QString::number(VERSION_MIC);
+ msgBox.setText("CatRadio Radio control software
version "+version+" "+RELEASE_DATE);
+ msgBox.setInformativeText("Copyright (C) 2022 Gianfranco Sordetti IZ8EWD
"
+ "www.pianetaradio.it"
+ "This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
"
+ "This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
"
+ "You should have received a copy of the GNU General Public License along with this program. If not, see www.gnu.org/licenses.");
+ msgBox.setIcon(QMessageBox::NoIcon);
+ msgBox.setStandardButtons(QMessageBox::Ok);
+
+ QPixmap icon("catradio.png");
+ msgBox.setIconPixmap(icon);
+
+ msgBox.exec();
+}
+
+void MainWindow::on_action_AboutQT_triggered()
+{
+ QMessageBox::aboutQt(this);
+}
+
+void MainWindow::on_action_AboutHamLib_triggered()
+{
+ QMessageBox msgBox;
+ msgBox.setWindowTitle("About Hamlib");
+ msgBox.setText(rig_version());
+ msgBox.setInformativeText(rig_copyright());
+ //msgBox.setDetailedText(rig_license());
+ msgBox.setIcon(QMessageBox::Information);
+ msgBox.setStandardButtons(QMessageBox::Ok);
+ msgBox.exec();
+}
+
+void MainWindow::on_action_CatRadioHomepage_triggered()
+{
+ QUrl homepage("https://www.pianetaradio.it/blog/catradio/");
+ QDesktopServices::openUrl(homepage);
+}
diff --git a/mainwindow.h b/mainwindow.h
new file mode 100644
index 0000000..8708b56
--- /dev/null
+++ b/mainwindow.h
@@ -0,0 +1,167 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include
+#include
+
+#define RELEASE_DATE __DATE__
+#define VERSION_MAJ 1
+#define VERSION_MIN 1
+#define VERSION_MIC 0
+
+
+QT_BEGIN_NAMESPACE
+namespace Ui { class MainWindow; }
+QT_END_NAMESPACE
+
+
+class MainWindow : public QMainWindow
+{
+ Q_OBJECT
+
+public:
+ MainWindow(QWidget *parent = nullptr);
+ ~MainWindow();
+
+public slots:
+ void guiUpdate();
+ void on_rigDaemonResultReady(); //Slot for rigDaemon resultReady
+ void on_vfoDisplayValueChanged(int value); //Slot for vfoDisplay valueChanged
+
+signals:
+
+private slots:
+ void on_pushButton_Connect_toggled(bool checked);
+ void on_pushButton_Power_toggled(bool checked);
+ void on_pushButton_PTT_toggled(bool checked);
+ void on_pushButton_Split_toggled(bool checked);
+ void on_pushButton_AB_clicked();
+ void on_pushButton_AeqB_clicked();
+
+ void on_dial_valueChanged(int value);
+
+ void on_comboBox_Mode_activated(int index);
+ void on_comboBox_ModeSub_activated(int index);
+
+ void on_pushButton_Fast_toggled(bool checked);
+
+ void on_pushButton_Band160_clicked();
+
+ void on_pushButton_Band80_clicked();
+
+ void on_pushButton_Band60_clicked();
+
+ void on_pushButton_Band40_clicked();
+
+ void on_pushButton_Band30_clicked();
+
+ void on_pushButton_Band20_clicked();
+
+ void on_pushButton_Band17_clicked();
+
+ void on_pushButton_Band15_clicked();
+
+ void on_pushButton_Band12_clicked();
+
+ void on_pushButton_Band10_clicked();
+
+ void on_pushButton_Band6_clicked();
+
+ void on_pushButton_Tune_clicked();
+
+ void on_radioButton_Tuner_toggled(bool checked);
+
+ void on_pushButton_BandDown_clicked();
+
+ void on_pushButton_BandUp_clicked();
+
+ void on_pushButton_QSplit_clicked();
+
+ void on_action_Connection_triggered();
+
+ void on_comboBox_BW_activated(int index);
+
+ void on_checkBox_NAR_toggled(bool checked);
+
+ void on_checkBox_BKIN_toggled(bool checked);
+
+ void on_comboBox_AGC_activated(int index);
+
+ void on_comboBox_Att_activated(int index);
+
+ void on_comboBox_Preamp_activated(int index);
+
+ void on_comboBox_Ant_activated(int index);
+
+ void on_action_AboutCatRadio_triggered();
+
+ void on_checkBox_NB_toggled(bool checked);
+
+ void on_checkBox_NR_toggled(bool checked);
+
+ void on_checkBox_NF_toggled(bool checked);
+
+ void on_comboBox_Meter_activated(int index);
+
+ void on_spinBox_NR_valueChanged(int arg1);
+
+ void on_horizontalSlider_IFshift_valueChanged(int value);
+
+ void on_pushButton_Band2_clicked();
+
+ void on_pushButton_Band70_clicked();
+
+ void on_pushButton_BandGen_clicked();
+
+ void on_action_Setup_triggered();
+ void on_action_CatRadioHomepage_triggered();
+ void on_action_AboutQT_triggered();
+ void on_action_AboutHamLib_triggered();
+
+ void on_verticalSlider_AFGain_valueChanged(int value);
+ void on_verticalSlider_Squelch_valueChanged(int value);
+ void on_verticalSlider_RFpower_valueChanged(int value);
+ void on_verticalSlider_RFgain_valueChanged(int value);
+
+ void on_spinBox_WPM_valueChanged(int arg1);
+
+ void on_checkBox_APF_toggled(bool checked);
+
+ void on_radioButton_RPTshiftSimplex_toggled(bool checked);
+
+ void on_radioButton_RPTshiftMinus_toggled(bool checked);
+
+ void on_radioButton_RPTshiftPlus_toggled(bool checked);
+
+ void on_comboBox_toneType_activated(int index);
+
+ void on_comboBox_toneFreq_activated(int index);
+
+private:
+ Ui::MainWindow *ui;
+ QTimer *timer;
+
+ void guiInit();
+ void setSubMeter();
+};
+
+#endif // MAINWINDOW_H
diff --git a/mainwindow.ui b/mainwindow.ui
new file mode 100644
index 0000000..cdf498e
--- /dev/null
+++ b/mainwindow.ui
@@ -0,0 +1,1580 @@
+
+
+ MainWindow
+
+
+ true
+
+
+
+ 0
+ 0
+ 610
+ 604
+
+
+
+ CatRadio
+
+
+
+ catradio.icocatradio.ico
+
+
+
+
+
+ 10
+ 10
+ 91
+ 401
+
+
+
+ -
+
+
+ Connect
+
+
+ true
+
+
+
+ -
+
+
+ Power
+
+
+ true
+
+
+
+ -
+
+
+ Qt::Vertical
+
+
+
+ 20
+ 40
+
+
+
+
+ -
+
+
+ Tuner
+
+
+
+ -
+
+
+ Tune
+
+
+
+ -
+
+
+ Antenna
+
+
+ comboBox_Ant
+
+
+
+ -
+
+
+ -
+
+
+ Qt::Vertical
+
+
+
+ 20
+ 40
+
+
+
+
+ -
+
+
+ AGC
+
+
+ comboBox_AGC
+
+
+
+ -
+
+
+ -
+
+
+ Attenuator
+
+
+ comboBox_Att
+
+
+
+ -
+
+
+ -
+
+
+ Preamp
+
+
+ comboBox_Preamp
+
+
+
+ -
+
+
+
+
+
+
+ true
+
+
+
+ 110
+ 80
+ 491
+ 131
+
+
+
+ QFrame::Box
+
+
+ QFrame::Raised
+
+
+ 0
+
+
+
+
+ 200
+ 10
+ 40
+ 16
+
+
+
+ VFO
+
+
+
+
+
+ 430
+ 10
+ 40
+ 16
+
+
+
+ VFO
+
+
+
+
+ true
+
+
+
+ 10
+ 60
+ 91
+ 24
+
+
+
+
+
+
+ 110
+ 60
+ 81
+ 24
+
+
+
+
+
+
+ 200
+ 30
+ 51
+ 16
+
+
+
+ RX TX
+
+
+
+
+
+ 430
+ 30
+ 51
+ 16
+
+
+
+ RX TX
+
+
+
+
+ true
+
+
+
+ 280
+ 10
+ 140
+ 40
+
+
+
+
+ 0
+ 0
+
+
+
+
+ 18
+
+
+
+ Qt::RightToLeft
+
+
+ Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
+
+
+ true
+
+
+
+
+ true
+
+
+
+ 280
+ 60
+ 91
+ 24
+
+
+
+ false
+
+
+
+
+
+ 10
+ 9
+ 181
+ 41
+
+
+
+
+
+
+ 10
+ 100
+ 381
+ 27
+
+
+
+ -
+
+
+ A / B
+
+
+
+ -
+
+
+ A = B
+
+
+
+ -
+
+
+ Split
+
+
+ true
+
+
+
+ -
+
+
+ Q Split
+
+
+
+
+
+
+
+
+
+ 110
+ 220
+ 161
+ 191
+
+
+
+ Band
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 1.8
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 3.5
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 5.3
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 7
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 10
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 14
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 18
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 21
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 24
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 28
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ Gen
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 50
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ <<
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 144
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ 430
+
+
+
+ -
+
+
+
+ 0
+ 0
+
+
+
+
+ 20
+ 20
+
+
+
+
+ 16
+ 16
+
+
+
+ >>
+
+
+
+
+
+
+
+
+ 480
+ 220
+ 121
+ 191
+
+
+
+ Filter
+
+
+
+
+ 10
+ 30
+ 51
+ 22
+
+
+
+ Noise Blanking
+
+
+ NB
+
+
+
+
+
+ 10
+ 60
+ 51
+ 22
+
+
+
+ Noise Reduction
+
+
+ NR
+
+
+
+
+
+ 10
+ 90
+ 51
+ 22
+
+
+
+ Notch Filter
+
+
+ NF
+
+
+
+
+
+ 70
+ 60
+ 46
+ 25
+
+
+
+ 1
+
+
+ 15
+
+
+
+
+
+ 10
+ 120
+ 61
+ 22
+
+
+
+ BW Narrow
+
+
+ NAR
+
+
+
+
+
+ 10
+ 170
+ 101
+ 18
+
+
+
+ -1200
+
+
+ 1200
+
+
+ 10
+
+
+ 100
+
+
+ false
+
+
+ Qt::Horizontal
+
+
+
+
+
+ 10
+ 150
+ 55
+ 16
+
+
+
+ IF-Shift
+
+
+ horizontalSlider_IFshift
+
+
+
+
+ true
+
+
+
+ 70
+ 150
+ 41
+ 16
+
+
+
+ 0
+
+
+ Qt::AlignCenter
+
+
+
+
+
+
+ 280
+ 220
+ 191
+ 191
+
+
+
+ QFrame::NoFrame
+
+
+ QFrame::Raised
+
+
+ 1
+
+
+
+
+ 10
+ 150
+ 171
+ 31
+
+
+
+ PTT
+
+
+ \
+
+
+ true
+
+
+
+
+
+ 25
+ 10
+ 140
+ 140
+
+
+
+ false
+
+
+ 100
+
+
+ true
+
+
+ true
+
+
+ 10.000000000000000
+
+
+ false
+
+
+
+
+
+ 10
+ 120
+ 41
+ 25
+
+
+
+ Fast
+
+
+ true
+
+
+
+
+
+ 10
+ 0
+ 61
+ 22
+
+
+
+ Main
+
+
+ true
+
+
+
+
+
+ 120
+ 0
+ 61
+ 22
+
+
+
+ Qt::RightToLeft
+
+
+ Sub
+
+
+
+
+
+
+ 110
+ 9
+ 491
+ 61
+
+
+
+ QFrame::NoFrame
+
+
+ QFrame::Raised
+
+
+ 0
+
+
+
+
+ 0
+ 0
+ 201
+ 61
+
+
+
+
+
+
+ 250
+ 0
+ 161
+ 61
+
+
+
+
+
+
+ 410
+ 20
+ 75
+ 24
+
+
+
+
+
+
+
+ 0
+ 420
+ 271
+ 131
+
+
+
+ QFrame::NoFrame
+
+
+ QFrame::Raised
+
+
+
+
+ 20
+ 20
+ 20
+ 80
+
+
+
+ 100
+
+
+ 100
+
+
+ Qt::Vertical
+
+
+ QSlider::TicksBothSides
+
+
+ 25
+
+
+
+
+
+ 90
+ 20
+ 18
+ 80
+
+
+
+ 100
+
+
+ 100
+
+
+ Qt::Vertical
+
+
+ QSlider::TicksBothSides
+
+
+ 25
+
+
+
+
+
+ 160
+ 20
+ 18
+ 80
+
+
+
+ 100
+
+
+ Qt::Vertical
+
+
+ QSlider::TicksBothSides
+
+
+ 25
+
+
+
+
+
+ 230
+ 20
+ 18
+ 80
+
+
+
+ 100
+
+
+ Qt::Vertical
+
+
+ QSlider::TicksBothSides
+
+
+ 25
+
+
+
+
+
+ 0
+ 100
+ 61
+ 16
+
+
+
+ RF Gain
+
+
+ Qt::AlignCenter
+
+
+
+
+ true
+
+
+
+ 15
+ 0
+ 30
+ 16
+
+
+
+
+ 0
+ 0
+
+
+
+ 100
+
+
+ Qt::AlignCenter
+
+
+
+
+
+ 65
+ 100
+ 71
+ 16
+
+
+
+ RF Power
+
+
+ Qt::AlignCenter
+
+
+
+
+ true
+
+
+
+ 85
+ 0
+ 30
+ 16
+
+
+
+
+ 0
+ 0
+
+
+
+ 100
+
+
+ Qt::AlignCenter
+
+
+
+
+ true
+
+
+
+ 155
+ 0
+ 30
+ 16
+
+
+
+
+ 0
+ 0
+
+
+
+ 0
+
+
+ Qt::AlignCenter
+
+
+
+
+
+ 140
+ 100
+ 61
+ 16
+
+
+
+ AF Gain
+
+
+ Qt::AlignCenter
+
+
+
+
+
+ 210
+ 100
+ 61
+ 16
+
+
+
+ Squelch
+
+
+ Qt::AlignCenter
+
+
+
+
+ true
+
+
+
+ 225
+ 0
+ 30
+ 16
+
+
+
+
+ 0
+ 0
+
+
+
+ 0
+
+
+ Qt::AlignCenter
+
+
+
+
+
+
+ 280
+ 419
+ 321
+ 131
+
+
+
+ false
+
+
+ 0
+
+
+
+ true
+
+
+ CW
+
+
+ -
+
+
+ Break-In
+
+
+ BK IN
+
+
+
+ -
+
+
-
+
+
+ WPM
+
+
+
+ -
+
+
+ 4
+
+
+ 60
+
+
+ 20
+
+
+
+
+
+ -
+
+
+ Audio Peak Filter
+
+
+ APF
+
+
+
+
+
+
+
+ true
+
+
+ FM
+
+
+ -
+
+
-
+
+
+ RPT Shift
+
+
+
+ -
+
+
+ Simplex
+
+
+ true
+
+
+
+ -
+
+
+ -
+
+
+
+ -
+
+
+ +
+
+
+
+
+
+ -
+
+
-
+
+
+ Tone
+
+
+
+ -
+
+
+
+
+ -
+
+
+
+
+
+ frame_2
+ frame
+ verticalLayoutWidget
+ groupBox_Band
+ groupBox_filter
+ frame_3
+ frame_4
+ tabWidget
+
+
+
+
+
+ Connection
+
+
+
+
+ About CatRadio
+
+
+
+
+ About HamLib
+
+
+
+
+ About QT
+
+
+
+
+ Setup
+
+
+
+
+ CatRadio homepage
+
+
+
+
+
+ SMeter
+ QWidget
+
+ 1
+
+
+ SubMeter
+ QWidget
+
+ 1
+
+
+ vfoDisplay
+ QWidget
+
+ 1
+
+
+
+
+
diff --git a/rigcommand.cpp b/rigcommand.cpp
new file mode 100644
index 0000000..a56a9c5
--- /dev/null
+++ b/rigcommand.cpp
@@ -0,0 +1,153 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#include "rigcommand.h"
+#include "rigdata.h"
+
+#include //Hamlib
+
+#include
+
+extern rigSettings rigGet;
+extern rigSettings rigSet;
+extern rigCommand rigCmd;
+extern rigCommand rigCap;
+
+void set_band (int band)
+{
+ freq_t freq;
+
+ switch (band)
+ {
+ case 160: freq = 1840000; break;
+ case 80: freq = 3600000; break;
+ case 60: freq = 5355000; break;
+ case 40: freq = 7100000; break;
+ case 30: freq = 10130000; break;
+ case 20: freq = 14100000; break;
+ case 17: freq = 18120000; break;
+ case 15: freq = 21150000; break;
+ case 12: freq = 24940000; break;
+ case 10: freq = 28320000; break;
+ case 6: freq = 50150000; break;
+ case 2: freq = 144300000; break;
+ case 70: freq = 432200000; break;
+ default: freq = rigSet.freqMain; break;
+ }
+
+ rigSet.freqMain = freq;
+ rigCmd.freqMain = 1;
+ rigCmd.bandChange = 1;
+}
+
+void quick_split ()
+{
+ if (rigGet.vfoMain == RIG_VFO_A)
+ {
+ rigSet.freqSub = rigGet.freqMain + 5000;
+ //rigSet.modeSub = rigGet.modeMain;
+ rigCmd.freqSub = 1;
+ //rigCmd.modeSub = 1;
+ }
+ else
+ {
+ rigSet.freqMain = rigGet.freqSub + 5000;
+ rigCmd.freqMain = 1;
+ }
+ rigCmd.split = 1;
+}
+
+agc_level_e levelagcvalue (int agcValue)
+{
+ agc_level_e agcLevel;
+
+ switch (agcValue)
+ {
+ case 0: agcLevel = RIG_AGC_OFF; break;
+ case 1: agcLevel = RIG_AGC_SUPERFAST; break;
+ case 2: agcLevel = RIG_AGC_FAST; break;
+ case 3: agcLevel = RIG_AGC_SLOW; break;
+ case 4: agcLevel = RIG_AGC_USER; break;
+ case 5: agcLevel = RIG_AGC_MEDIUM; break;
+ case 6: agcLevel = RIG_AGC_AUTO; break;
+ default: agcLevel = RIG_AGC_AUTO; break;
+ }
+
+ return agcLevel;
+}
+
+agc_level_e levelagcstr (QString agcString)
+{
+ agc_level_e agcLevel;
+
+ if (agcString == "OFF") agcLevel = RIG_AGC_OFF;
+ else if (agcString == "SUPERFAST") agcLevel = RIG_AGC_SUPERFAST;
+ else if (agcString == "FAST") agcLevel = RIG_AGC_FAST;
+ else if (agcString == "SLOW") agcLevel = RIG_AGC_SLOW;
+ else if (agcString == "USER") agcLevel = RIG_AGC_USER;
+ else if (agcString == "MEDIUM") agcLevel = RIG_AGC_MEDIUM;
+ else agcLevel = RIG_AGC_AUTO;
+
+ return agcLevel;
+}
+
+value_t valueagclevel (agc_level_e agcLevel)
+{
+ value_t value;
+
+ if (agcLevel == RIG_AGC_OFF) value.i = 0;
+ else if (agcLevel == RIG_AGC_SUPERFAST) value.i = 1;
+ else if (agcLevel == RIG_AGC_FAST) value.i = 2;
+ else if (agcLevel == RIG_AGC_SLOW) value.i = 3;
+ else if (agcLevel == RIG_AGC_USER) value.i = 4;
+ else if (agcLevel == RIG_AGC_MEDIUM) value.i = 5;
+ else value.i = 6; //RIG_AGC_AUTO
+
+ return value;
+}
+
+ant_t antstr (QString antString)
+{
+ ant_t ant;
+
+ if (antString == "NONE") ant = RIG_ANT_NONE;
+ else if (antString == "ANT1") ant = RIG_ANT_1;
+ else if (antString == "ANT2") ant = RIG_ANT_2;
+ else if (antString == "ANT3") ant = RIG_ANT_3;
+ else if (antString == "ANT4") ant = RIG_ANT_4;
+ else if (antString == "ANT5") ant = RIG_ANT_5;
+ else if (antString == "UNK") ant = RIG_ANT_UNKNOWN;
+ else if (antString == "CURR") ant = RIG_ANT_CURR;
+ else ant = RIG_ANT_UNKNOWN;
+
+ return ant;
+}
+
+unsigned levelmeterstr (QString meterString)
+{
+ unsigned levelMeter;
+
+ if (meterString == "SWR") levelMeter = RIG_LEVEL_SWR;
+ else if (meterString == "COMP") levelMeter = RIG_LEVEL_COMP;
+ else if (meterString == "ALC") levelMeter = RIG_LEVEL_ALC;
+ //...
+ else levelMeter = RIG_METER_NONE;
+
+ return levelMeter;
+}
diff --git a/rigcommand.h b/rigcommand.h
new file mode 100644
index 0000000..7c76aeb
--- /dev/null
+++ b/rigcommand.h
@@ -0,0 +1,36 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#ifndef RIGCOMMAND_H
+#define RIGCOMMAND_H
+
+#endif // RIGCOMMAND_H
+
+#include
+
+#include
+
+
+void set_band (int band);
+void quick_split ();
+agc_level_e levelagcvalue (int agcValue);
+agc_level_e levelagcstr (QString agcString);
+value_t valueagclevel (agc_level_e agcLevel);
+ant_t antstr (QString antString);
+unsigned levelmeterstr (QString meterString);
diff --git a/rigdaemon.cpp b/rigdaemon.cpp
new file mode 100644
index 0000000..e376179
--- /dev/null
+++ b/rigdaemon.cpp
@@ -0,0 +1,593 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#include "rigdaemon.h"
+#include "rigdata.h"
+#include "rigcommand.h"
+
+#include
+#include
+#include
+
+#include
+
+
+RIG *my_rig;
+
+extern rigConnect rigCom;
+extern rigSettings rigGet;
+extern rigSettings rigSet;
+extern rigCommand rigCmd;
+extern rigCommand rigCap;
+
+int commandPriority = 0;
+
+
+RigDaemon::RigDaemon(QObject *parent) : QObject(parent)
+{
+
+}
+
+int RigDaemon::rigConnect()
+{
+ int retcode;
+
+ my_rig = rig_init(rigCom.rigModel); //Allocate rig handle
+
+ if (!my_rig) //Wrong Rig number
+ {
+ QMessageBox msgBox; //Show error MessageBox
+ msgBox.setWindowTitle("Warning");
+ msgBox.setText("Rig model error");
+ msgBox.setIcon(QMessageBox::Warning);
+ msgBox.setStandardButtons(QMessageBox::Ok);
+ msgBox.exec();
+
+ return -1; //RIG_EINVAL, Invalid parameter
+ }
+ else
+ {
+ if (rigCom.rigModel == 2) //Rigctld
+ {
+ //myport.type.rig = RIG_PORT_NETWORK;
+ strncpy(my_rig->state.rigport.pathname, rigCom.rigPort.toLatin1(), HAMLIB_FILPATHLEN - 1);
+ //strncpy(my_rig->state.rigport.pathname, RIG_FILE, HAMLIB_FILPATHLEN - 1);
+ }
+ else
+ {
+ //myport.type.rig = RIG_PORT_SERIAL;
+ strncpy(my_rig->state.rigport.pathname, rigCom.rigPort.toLatin1(), HAMLIB_FILPATHLEN - 1);
+ my_rig->state.rigport.parm.serial.rate = rigCom.serialSpeed;
+ if (rigCom.civAddr) //CI-V address Icom
+ {
+ std::string civaddrS = std::to_string(rigCom.civAddr); //Convert int to string
+ char const *civaddr = civaddrS.c_str(); //Convert string to char*
+ rig_set_conf(my_rig, rig_token_lookup(my_rig, "civaddr"), civaddr);
+ }
+ }
+
+ retcode = rig_open(my_rig);
+
+ if (retcode != RIG_OK) return retcode; //Rig not connected
+ else //Rig connected
+ {
+ rig_get_powerstat(my_rig, &rigGet.onoff);
+ return 0;
+ }
+
+ }
+}
+
+void RigDaemon::rigUpdate()
+{
+ int retcode;
+ value_t retvalue;
+
+ //***** Priority Command execution *****
+ //* PTT
+ if (rigCmd.ptt)
+ {
+ retcode = rig_set_ptt(my_rig, RIG_VFO_CURR, rigSet.ptt);
+ if (retcode == RIG_OK) rigGet.ptt = rigSet.ptt;
+ rigCmd.ptt = 0;
+ }
+
+ //* VFO
+ if (rigCmd.freqMain) //VFO Main
+ {
+ retcode = rig_set_freq(my_rig, RIG_VFO_CURR, rigSet.freqMain);
+ if (retcode == RIG_OK) rigGet.freqMain = rigSet.freqMain;
+ rigCmd.freqMain = 0;
+ rigCmd.rangeList = 1;
+ }
+
+ else if (rigCmd.freqSub) //VFO Sub
+ {
+ retcode = rig_set_freq(my_rig, rigGet.vfoSub, rigSet.freqSub);
+ if (retcode == RIG_OK) rigGet.freqSub = rigSet.freqSub;
+ rigCmd.freqSub = 0;
+ }
+
+ //***** Priority Poll execution *****
+ else
+ {
+ freq_t retfreq;
+ retcode = rig_get_freq(my_rig, RIG_VFO_CURR, &retfreq); //get VFO Main
+ if (retcode == RIG_OK) rigGet.freqMain = retfreq;
+ //if (my_rig->caps->targetable_vfo) //get VFO Sub if targetable
+ //{
+ retcode = rig_get_freq(my_rig, rigGet.vfoSub, &retfreq);
+ if (retcode == RIG_OK) rigGet.freqSub = retfreq;
+ //}
+
+ //* PTT
+ ptt_t retptt;
+ retcode = rig_get_ptt(my_rig, RIG_VFO_CURR, &retptt);
+ if (retcode == RIG_OK) rigGet.ptt = retptt;
+
+ //* Meter
+ if (rigGet.ptt==1)
+ {
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_RFPOWER_METER, &rigGet.powerMeter);
+ rig_get_level(my_rig, RIG_VFO_CURR, rigSet.meter, &rigGet.subMeter);
+ }
+ else
+ {
+ retcode = rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_STRENGTH, &retvalue);
+ if (retcode == RIG_OK) rigGet.sMeter = retvalue;
+ }
+
+ //***** Command execution *****
+ if (!rigGet.ptt)
+ {
+ //* Mode
+ if (rigCmd.mode && rigSet.mode != RIG_MODE_NONE) //VFO Main
+ {
+ retcode = rig_set_mode(my_rig, RIG_VFO_CURR, rigSet.mode, RIG_PASSBAND_NOCHANGE);
+ if (retcode == RIG_OK)
+ {
+ rigCmd.bwidthList = 1; //Update BWidth list
+ commandPriority = 0;
+ //rig_get_mode(my_rig, RIG_VFO_CURR, &rigGet.mode, &rigGet.bwidth); //Get BW
+ }
+ rigCmd.mode = 0;
+ }
+ if (rigCmd.modeSub && rigCap.modeSub && rigSet.modeSub != RIG_MODE_NONE) //VFO Sub
+ {
+ retcode = rig_set_mode(my_rig, rigGet.vfoSub, rigSet.mode, RIG_PASSBAND_NOCHANGE);
+ if (retcode == RIG_OK)
+ {
+ }
+ rigCmd.modeSub = 0;
+ }
+
+ //* BandWidth
+ if (rigCmd.bwidth)
+ {
+ retcode = rig_set_mode(my_rig, RIG_VFO_CURR, rigGet.mode, rigSet.bwidth);
+ if (retcode == RIG_OK) rigGet.bwidth = rigSet.bwidth;
+ rigCmd.bwidth = 0;
+ }
+
+ //* Split
+ if (rigCmd.split)
+ {
+ retcode = rig_set_split_vfo(my_rig, RIG_VFO_RX, rigSet.split, RIG_VFO_TX);
+ if (retcode == RIG_OK) rigGet.split = rigSet.split;
+ rigCmd.split = 0;
+ }
+
+ //* VFO Exchange
+ if (rigCmd.vfoXchange)
+ {
+ int tempMode = rigGet.mode;
+ retcode = rig_vfo_op(my_rig, RIG_VFO_CURR, RIG_OP_XCHG);
+ if (retcode == RIG_OK)
+ {
+ if (rigCap.modeSub == 0) rigGet.modeSub = tempMode;
+ commandPriority = 0;
+ }
+ rigCmd.vfoXchange = 0;
+ rigCmd.bwidthList = 1;
+ }
+
+ //* VFO Copy
+ if (rigCmd.vfoCopy)
+ {
+ rig_vfo_op(my_rig, RIG_VFO_CURR, RIG_OP_CPY);
+ rigCmd.vfoCopy = 0;
+ if (rigCap.modeSub == 0) rigGet.modeSub = rigGet.mode;
+ }
+
+ //* Band Up
+ if (rigCmd.bandUp)
+ {
+ retcode = rig_vfo_op(my_rig, RIG_VFO_CURR, RIG_OP_BAND_UP);
+ if (retcode == RIG_OK) commandPriority = 0;
+ rigCmd.bandUp = 0;
+ rigCmd.bwidthList = 1;
+ }
+
+ //* Band Down
+ if (rigCmd.bandDown)
+ {
+ retcode = rig_vfo_op(my_rig, RIG_VFO_CURR, RIG_OP_BAND_DOWN);
+ if (retcode == RIG_OK) commandPriority = 0;
+ rigCmd.bandDown = 0;
+ rigCmd.bwidthList = 1;
+ }
+
+ //* Band change
+ if (rigCmd.bandChange)
+ {
+ commandPriority = 0;
+ rigCmd.bwidthList = 1;
+ }
+
+ //* Tune
+ if (rigCmd.tune)
+ {
+ rig_vfo_op(my_rig, RIG_VFO_CURR, RIG_OP_TUNE);
+ rigCmd.tune = 0;
+ }
+
+ //* Antenna
+ if (rigCmd.ant)
+ {
+ retcode = rig_set_ant(my_rig, RIG_VFO_CURR, rigSet.ant, retvalue);
+ if (retcode == RIG_OK) rigGet.ant = rigSet.ant;
+ rigCmd.ant = 0;
+ }
+
+ //* AGC
+ if (rigCmd.agc)
+ {
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_AGC, valueagclevel(rigSet.agc));
+ if (retcode == RIG_OK) rigGet.agc = rigSet.agc;
+ rigCmd.agc = 0;
+ }
+
+ //* Attenuator
+ if (rigCmd.att)
+ {
+ retvalue.i = rigSet.att;
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_ATT, retvalue);
+ if (retcode == RIG_OK) rigGet.att = rigSet.att;
+ rigCmd.att = 0;
+ }
+
+ //* Preamp
+ if (rigCmd.pre)
+ {
+ retvalue.i = rigSet.pre;
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_PREAMP, retvalue);
+ if (retcode == RIG_OK) rigGet.pre = rigSet.pre;
+ rigCmd.pre = 0;
+ }
+
+ //* RF gain
+ if (rigCmd.rfGain)
+ {
+ retvalue.f = rigSet.rfGain;
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_RF, retvalue);
+ if (retcode == RIG_OK) rigGet.rfGain = rigSet.rfGain;
+ rigCmd.rfGain = 0;
+ }
+
+ //* AF Gain
+ if (rigCmd.afGain)
+ {
+ retvalue.f = rigSet.afGain;
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_AF, retvalue);
+ if (retcode == RIG_OK) rigGet.afGain = rigSet.afGain;
+ rigCmd.afGain = 0;
+ }
+
+ //* Squelch
+ if (rigCmd.squelch)
+ {
+ retvalue.f = rigSet.squelch;
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_SQL, retvalue);
+ if (retcode == RIG_OK) rigGet.squelch = rigSet.squelch;
+ rigCmd.squelch = 0;
+ }
+
+ //* NB noise blanker
+ if (rigCmd.noiseBlanker)
+ {
+ retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_NB, rigSet.noiseBlanker);
+ if (retcode == RIG_OK) rigGet.noiseBlanker = rigSet.noiseBlanker;
+ rigCmd.noiseBlanker = 0;
+ }
+
+ //* NR noise reduction
+ if (rigCmd.noiseReduction)
+ {
+ retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_NR, rigSet.noiseReduction);
+ if (retcode == RIG_OK) rigGet.noiseReduction = rigSet.noiseReduction;
+ rigCmd.noiseReduction = 0;
+ }
+
+ if (rigCmd.noiseReductionLevel)
+ {
+ retvalue.i = rigSet.noiseReductionLevel;
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_NR, retvalue);
+ if (retcode == RIG_OK) rigGet.noiseReductionLevel = rigSet.noiseReductionLevel;
+ rigCmd.noiseReductionLevel = 0;
+ }
+
+ //* NF notch filter
+ if (rigCmd.notchFilter)
+ {
+ retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_ANF, rigSet.notchFilter);
+ if (retcode == RIG_OK) rigGet.notchFilter = rigSet.notchFilter;
+ rigCmd.notchFilter = 0;
+ }
+
+ //* IF Shift
+ if (rigCmd.ifShift)
+ {
+ retvalue.i = rigSet.ifShift;
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_IF, retvalue);
+ if (retcode == RIG_OK) rigGet.ifShift = rigSet.ifShift;
+ rigCmd.ifShift = 0;
+ }
+
+ //** CW
+ //* CW break-in
+ if (rigCmd.bkin)
+ {
+ retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_FBKIN, rigSet.bkin);
+ if (retcode == RIG_OK) rigGet.bkin = rigSet.bkin;
+ rigCmd.bkin = 0;
+ }
+ //* CW Auto Peak Filter
+ if (rigCmd.apf)
+ {
+ retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_APF, rigSet.apf);
+ if (retcode == RIG_OK) rigGet.apf = rigSet.apf;
+ rigCmd.apf = 0;
+ }
+ //* CW keyer speed
+ if (rigCmd.wpm)
+ {
+ retvalue.i = rigSet.wpm;
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_KEYSPD, retvalue);
+ if (retcode == RIG_OK) rigGet.wpm = rigSet.wpm;
+ rigCmd.wpm = 0;
+ }
+
+ //** FM
+ //* Repeater shift
+ if (rigCmd.rptShift)
+ {
+ retcode = rig_set_rptr_shift(my_rig, RIG_VFO_CURR, rigSet.rptShift);
+ if (retcode == RIG_OK) rigGet.rptShift = rigSet.rptShift;
+ rigCmd.rptShift = 0;
+ }
+ //* Tone
+ if (rigCmd.tone)
+ {
+ switch (rigSet.toneType)
+ {
+ case 1:
+ retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TBURST, true);
+ break;
+ case 2:
+ retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TONE, true);
+ if (rigSet.tone) rig_set_ctcss_tone(my_rig, RIG_VFO_CURR, rigSet.tone);
+ else rig_get_ctcss_tone(my_rig, RIG_VFO_CURR, &rigSet.tone);
+ break;
+ case 3:
+ retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TSQL, true);
+ if (rigSet.tone) rig_set_ctcss_tone(my_rig, RIG_VFO_CURR, rigSet.tone);
+ else rig_get_ctcss_tone(my_rig, RIG_VFO_CURR, &rigSet.tone);
+ break;
+ default:
+ rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TBURST, false);
+ rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TONE, false);
+ rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TSQL, false);
+ retcode = RIG_OK;
+ break;
+ }
+ if (retcode == RIG_OK)
+ {
+ rigGet.toneType = rigSet.toneType;
+ rigGet.tone = rigSet.tone;
+ }
+ rigCmd.tone = 0;
+ rigCmd.toneList = 1;
+ }
+
+ } //end if (!rigGet.ptt)
+
+ //* Tuner
+ if (rigCmd.tuner)
+ {
+ retcode = rig_set_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TUNER, rigSet.tuner);
+ if (retcode == RIG_OK) rigGet.tuner = rigSet.tuner;
+ rigCmd.tune = 0;
+ }
+
+ //* RF power
+ if (rigCmd.rfPower)
+ {
+ retvalue.f = rigSet.rfPower;
+ retcode = rig_set_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_RFPOWER, retvalue);
+ if (retcode == RIG_OK) rigGet.rfPower = rigSet.rfPower;
+ rigCmd.rfPower = 0;
+ }
+
+ //***** Poll execution *****
+ //* Mode and BW
+ if ((commandPriority == 1 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_mode(my_rig, RIG_VFO_CURR, &rigGet.mode, &rigGet.bwidth);
+ if (rigGet.bwidth == rig_passband_narrow(my_rig, rigGet.mode)) rigGet.bwNarrow = 1;
+ else rigGet.bwNarrow = 0;
+
+ if (rigCap.modeSub)
+ {
+ retcode = rig_get_mode(my_rig, rigGet.vfoSub, &rigGet.modeSub, &rigGet.bwidthSub);
+ if (retcode != RIG_OK)
+ {
+ rigCap.modeSub = 0; //mode not targetable
+ rigGet.modeSub = RIG_MODE_NONE;
+ }
+ }
+ }
+
+ //* Split
+ if ((commandPriority == 2 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_split_vfo(my_rig, RIG_VFO_CURR, &rigGet.split, &rigGet.vfoTx);
+ //else rig_get_split(my_rig, RIG_VFO_CURR, &rigGet.split);
+
+ rig_get_vfo(my_rig, &rigGet.vfoMain);
+ }
+
+ //* Tuner
+ if ((commandPriority == 3 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0) rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TUNER, &rigGet.tuner);
+
+ //* Antenna
+ if ((commandPriority == 4 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0) rig_get_ant(my_rig, RIG_VFO_CURR, RIG_ANT_CURR, &retvalue, &rigGet.ant, &rigGet.antTx, &rigGet.antRx);
+
+ //* AGC
+ if ((commandPriority == 5 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_AGC, &retvalue);
+ rigGet.agc = levelagcvalue(retvalue.i);
+ }
+
+ //* Attenuator
+ if ((commandPriority == 6 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_ATT, &retvalue);
+ rigGet.att = retvalue.i;
+ }
+
+ //* Preamp
+ if ((commandPriority == 7 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_PREAMP, &retvalue);
+ rigGet.pre = retvalue.i;
+ }
+
+ //* RF power
+ if ((commandPriority == 8 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_RFPOWER, &retvalue);
+ rigGet.rfPower = retvalue.f;
+ }
+
+ //* RF gain
+ if ((commandPriority == 9 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_RF, &retvalue);
+ rigGet.rfGain = retvalue.f;
+ }
+
+ //* AF gain
+ if ((commandPriority == 10 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_AF, &retvalue);
+ rigGet.afGain = retvalue.f;
+ }
+
+ //* Squelch
+ if ((commandPriority == 11 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_SQL, &retvalue);
+ rigGet.squelch = retvalue.f;
+ }
+
+ //* NB noise blanker
+ if ((commandPriority == 12 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0) rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_NB, &rigGet.noiseBlanker);
+
+ //* NR noise reduction
+ if ((commandPriority == 13 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_NR, &rigGet.noiseReduction);
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_NR, &retvalue);
+ rigGet.noiseReductionLevel = retvalue.i;
+ }
+
+ //* NF notch filter
+ if ((commandPriority == 14 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0) rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_ANF, &rigGet.notchFilter);
+
+ //* IF Shift
+ if ((commandPriority == 15 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0)
+ {
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_IF, &retvalue);
+ rigGet.ifShift = retvalue.i;
+ }
+
+ //* CW
+ if ((commandPriority == 16 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0) //&& mode=CW
+ {
+ rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_FBKIN, &rigGet.bkin); //Break-in
+ rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_APF, &rigGet.apf); //Audio Peak Filter
+ rig_get_level(my_rig, RIG_VFO_CURR, RIG_LEVEL_KEYSPD, &retvalue); //Keyer speed WPM
+ rigGet.wpm = retvalue.i;
+ }
+
+ //* FM
+ if ((commandPriority == 17 && !rigGet.ptt && rigCom.fullPoll) || commandPriority == 0) //&& mode=FM
+ {
+ rig_get_rptr_shift(my_rig, RIG_VFO_CURR, &rigGet.rptShift); //Repeater Shift
+
+ int status = false;
+ if (!status)
+ {
+ rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TBURST, &status); //1750 Hz Tone burst
+ if (status) rigGet.toneType = 1;
+ }
+ if (!status)
+ {
+ rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TONE, &status); //CTCSS Tone Tx
+ if (status) rigGet.toneType = 2;
+ }
+ if (!status)
+ {
+ rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_TSQL, &status); //CTCSS Tone Tx and Rx Squelch
+ if (status) rigGet.toneType = 3;
+ }
+ if (!status) rigGet.toneType = 0;
+
+ if (rigGet.toneType == 2 || rigGet.toneType == 3) rig_get_ctcss_tone(my_rig, RIG_VFO_CURR, &rigGet.tone);
+ else if (rigGet.toneType == 4 || rigGet.toneType == 5) rig_get_dcs_code(my_rig, RIG_VFO_CURR, &rigGet.tone);
+
+ if (rigGet.toneType && rigGet.tone == 0)
+ {
+ rigSet.toneType = 0;
+ rigCmd.tone = 1;
+ }
+
+ if (rigGet.toneType != rigSet.toneType) rigCmd.toneList = 1; //update tone list
+
+ //rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_CSQL, &status);
+ //rig_get_func(my_rig, RIG_VFO_CURR, RIG_FUNC_DSQL, &status);
+ }
+
+ commandPriority ++;
+ if (commandPriority == 18) commandPriority = 1;
+ }
+
+ emit resultReady();
+}
diff --git a/rigdaemon.h b/rigdaemon.h
new file mode 100644
index 0000000..4020535
--- /dev/null
+++ b/rigdaemon.h
@@ -0,0 +1,42 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#ifndef RIGDAEMON_H
+#define RIGDAEMON_H
+
+#include
+#include
+
+class RigDaemon : public QObject
+{
+ Q_OBJECT
+
+public:
+ explicit RigDaemon(QObject *parent = nullptr);
+ int rigConnect();
+
+public slots:
+ void rigUpdate();
+
+signals:
+ void resultReady();
+
+};
+
+#endif // RIGDAEMON_H
diff --git a/rigdata.cpp b/rigdata.cpp
new file mode 100644
index 0000000..84560e7
--- /dev/null
+++ b/rigdata.cpp
@@ -0,0 +1,26 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#include "rigdata.h"
+
+rigConnect rigCom;
+rigSettings rigGet;
+rigSettings rigSet;
+rigCommand rigCmd;
+rigCommand rigCap;
diff --git a/rigdata.h b/rigdata.h
new file mode 100644
index 0000000..e38ecbc
--- /dev/null
+++ b/rigdata.h
@@ -0,0 +1,111 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#ifndef RIGDATA_H
+#define RIGDATA_H
+
+#endif // RIGDATA_H
+
+#include //Hamlib
+
+#include
+
+typedef struct {
+ unsigned rigModel; //Hamlib rig model
+ QString rigPort; //COM port or IP address
+ unsigned serialSpeed; //Serial port baud rate
+ int civAddr; //CI-V address (decimal, Icom radio)
+ unsigned rigRefresh; //GUI refresh interval (ms)
+ int connected; //connected flag
+ bool fullPoll; //full polling flag
+} rigConnect;
+
+typedef struct {
+ powerstat_t onoff; //on/off status
+ freq_t freqMain, freqSub; //Frequency
+ rmode_t mode, modeSub; //Mode
+ pbwidth_t bwidth, bwidthSub; //IF filter bandwidth
+ int bwNarrow; //IF narrow filter
+ vfo_t vfoMain, vfoSub; //VFO
+ vfo_t vfoTx;
+ split_t split; //Split
+ ptt_t ptt; //PTT
+ value_t sMeter; //Smeter signal strenght
+ value_t powerMeter; //RF power meter
+ value_t subMeter; //secondary meter
+ unsigned meter; //secondary meter type
+ float rfPower; //RF power output level
+ float rfGain; //RF gain rx
+ float afGain; //AF gain level
+ float squelch; //Squelch level
+ agc_level_e agc; //AGC level
+ int att; //Attenuator
+ int pre; //Preamplifier
+ ant_t ant, antTx, antRx; //Antenna
+ int rangeListTxIndex, rangeListRxIndex;
+ int tuner; //Tuner
+ int bkin; //CW Break-in
+ int wpm; //CW Keyer speed WPM
+ int apf; //Audio Peak Filter
+ int noiseBlanker;
+ int noiseReduction, noiseReductionLevel;
+ int notchFilter;
+ int ifShift;
+ rptr_shift_t rptShift; //Repeater shift
+ int toneType; //0 none, 1 burst 1750, 2 CTCSS, 3 CTCSS SQL, 4 DCS, 5 DCS SQL
+ tone_t tone; //CTCSS or DCS tone
+} rigSettings;
+
+typedef struct {
+ int onoff;
+ int freqMain, freqSub;
+ int mode, modeSub;
+ int bwidth;
+ int bwidthList;
+ int vfo;
+ int split;
+ int vfoXchange;
+ int vfoCopy;
+ int ptt;
+ int rfPower;
+ int rfGain;
+ int afGain;
+ int squelch;
+ int agc;
+ int att;
+ int pre;
+ int ant;
+ int tuner;
+ int tune;
+ int bandUp;
+ int bandDown;
+ int bandChange;
+ int bkin;
+ int wpm;
+ int apf;
+ int noiseBlanker;
+ int noiseReduction, noiseReductionLevel;
+ int notchFilter;
+ int ifShift;
+ int rptShift;
+ int tone;
+ int antList;
+ int rangeList;
+ int toneList;
+} rigCommand;
diff --git a/smeter.cpp b/smeter.cpp
new file mode 100644
index 0000000..d23bfd8
--- /dev/null
+++ b/smeter.cpp
@@ -0,0 +1,319 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#include "smeter.h"
+#include
+#include
+
+SMeter::SMeter(QWidget *parent) : QWidget(parent)
+{
+ lineColor = QColor(Qt::black);
+ bgColor = QColor(Qt::white);
+ progressColor = QColor(Qt::green);
+
+ //Default value
+ minValue = 0;
+ maxValue = 100;
+ gateValue = 80;
+ longStep = 20;
+ shortStep = 10;
+ precision = 0;
+
+ meterTx = 0;
+
+ currentValue = -54;
+}
+
+void SMeter::paintEvent(QPaintEvent *)
+{
+ QPainter painter(this);
+ painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
+
+ QFont font;
+ font = painter.font();
+ font.setPointSize(font.pointSize() - 2);
+ painter.setFont(font);
+
+ drawMeter(&painter);
+ drawProgress(&painter);
+ drawScaleSMeter(&painter);
+ drawScalePWRMeter(&painter);
+}
+
+void SMeter::drawMeter(QPainter *painter)
+{
+ painter->save();
+
+ QPen pen(lineColor, 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin);
+ painter->setPen(pen);
+ painter->setBrush(bgColor);
+ painter->drawRect(0, height()/3+2, width()-12, height()/3-4);
+ painter->restore();
+}
+
+void SMeter::drawProgress(QPainter *painter)
+{
+ double max, min;
+ double gate;
+
+ painter->save();
+ painter->setPen(Qt::NoPen);
+ painter->setBrush(progressColor);
+
+ if (meterTx) //RF power meter
+ {
+ max = maxValue;
+ min = minValue;
+ gate = gateValue;
+ }
+ else //SMeter
+ {
+ max = 60;
+ min = -54;
+ gate = 0;
+ }
+
+ double length = width()-14;
+ double increment = length / (max - min);
+ double initX, initXX;
+
+ if (currentValue>gate)
+ {
+ initX = (gate - min) * increment;
+ QRect rect(1, height()/3+2+1, initX, height()/3-4-2);
+ painter->drawRect(rect);
+
+ //Red bar
+ initXX = (currentValue - gate) * increment;
+ QRect rect2(initX+1, height()/3+2+1, initXX, height()/3-4-2);
+ painter->setBrush(Qt::red);
+ painter->drawRect(rect2);
+ }
+ else
+ {
+ initX = (currentValue - min) * increment;
+ QRect rect(1, height()/3+2+1, initX, height()/3-4-2);
+ painter->drawRect(rect);
+ }
+
+ painter->restore();
+}
+
+void SMeter::drawScalePWRMeter(QPainter *painter)
+{
+ painter->save();
+ painter->setPen(lineColor);
+
+ double initX = 0;
+ double initTopY = height()*2/3-2;
+ double length = width()-12;
+ double increment = length / (maxValue - minValue);
+
+ int longLineLen = 6;
+ int shortLineLen = 3;
+
+ QFontMetrics meterFont(painter->font());
+ double textHeight = meterFont.height();
+
+ //Draw scale and scale values based on range values Long lines
+ int stepNumber = (maxValue - minValue) / shortStep;
+ for (int i = 0; i <= stepNumber; i++)
+ {
+ double j = i * shortStep + minValue;
+ if (fmod(j,longStep) == 0)
+ {
+ if (j == minValue) //Do not draw the first value
+ {
+ QPointF textPot = QPointF(initX, initTopY + textHeight);
+ painter->drawText(textPot, "PO");
+
+ initX += increment * shortStep;
+ continue;
+ }
+
+ QPointF topPot = QPointF(initX, initTopY);
+ QPointF bottomPot = QPointF(initX, initTopY + longLineLen);
+ painter->drawLine(topPot, bottomPot);
+
+ QString strValue = QString("%1").arg(j, 0, 'f', precision);
+ double textWidth = fontMetrics().horizontalAdvance(strValue);
+
+ QPointF textPot = QPointF(initX - textWidth / 2, initTopY + textHeight + longLineLen - 2);
+ painter->drawText(textPot, strValue);
+ }
+ else
+ {
+
+ QPointF topPot = QPointF(initX, initTopY);
+ QPointF bottomPot = QPointF(initX, initTopY + shortLineLen);
+ painter->drawLine(topPot, bottomPot);
+ }
+
+ initX += increment * shortStep;
+ }
+
+ painter->restore();
+}
+
+void SMeter::drawScaleSMeter(QPainter *painter)
+{
+ int minValue = -54; //Set min and max value according to Hamlib SMeter definition
+ int maxValue = 60;
+
+ int longLineLen = 6;
+ int shortLineLen = 3;
+
+ double initX = 0;
+ int sUnit = 0;
+
+ double initBottomY = height()/3+2;
+ double length = width()-12;
+ double increment = length / (maxValue - minValue);
+
+ QFontMetrics meterFont(painter->font());
+ double textHeight = meterFont.height();
+
+ painter->save();
+ painter->setPen(lineColor);
+
+ //Draw scale and scale values based on range values
+ int longStep = 12;
+ int shortStep = 6;
+
+ for (int i = minValue; i <= 0; i = i + shortStep) //S0 to S9
+ {
+ if (i == minValue)
+ {
+ QPointF textPot = QPointF(initX, initBottomY - 2);
+ painter->drawText(textPot, "S");
+
+ initX += increment * shortStep;
+ sUnit = sUnit + 1;
+ continue;
+ }
+
+ if (i % longStep == 0)
+ {
+ QPointF topPot = QPointF(initX, initBottomY);
+ QPointF bottomPot = QPointF(initX, initBottomY - longLineLen);
+ painter->drawLine(topPot, bottomPot);
+
+ QString strValue = QString::number(sUnit);
+ double textWidth = fontMetrics().horizontalAdvance(strValue);
+ QPointF textPot = QPointF(initX - textWidth / 2, initBottomY - textHeight / 2 - longLineLen + 2);
+ painter->drawText(textPot, strValue);
+ }
+ else
+ {
+ QPointF topPot = QPointF(initX, initBottomY);
+ QPointF bottomPot = QPointF(initX, initBottomY - shortLineLen);
+ painter->drawLine(topPot, bottomPot);
+ }
+
+ sUnit = sUnit + 1;
+ initX += increment * shortStep;
+ }
+ initX -= increment * shortStep;
+
+ shortStep = 10;
+ longStep = 20;
+
+ for (int i = 0; i <= maxValue; i = i + shortStep) //S9+ to S9+60
+ {
+ if (i % longStep == 0)
+ {
+ QPointF topPot = QPointF(initX, initBottomY);
+ QPointF bottomPot = QPointF(initX, initBottomY - longLineLen);
+ painter->drawLine(topPot, bottomPot);
+
+ if (i == 0) //Do not draw the first value
+ {
+ initX += increment * shortStep;
+ continue;
+ }
+
+ QString strValue = "+" + QString::number(i);
+ double textWidth = fontMetrics().horizontalAdvance(strValue);
+
+ QPointF textPot = QPointF(initX - textWidth / 2, initBottomY - textHeight / 2 - longLineLen + 2);
+ painter->drawText(textPot, strValue);
+ }
+ else
+ {
+ QPointF topPot = QPointF(initX, initBottomY);
+ QPointF bottomPot = QPointF(initX, initBottomY - shortLineLen);
+ painter->drawLine(topPot, bottomPot);
+ }
+
+ initX += increment * shortStep;
+ }
+
+ painter->restore();
+}
+
+void SMeter::setMinValue(double value)
+{
+ minValue = value;
+ update();
+}
+
+void SMeter::setMaxValue(double value)
+{
+ maxValue = value;
+ update();
+}
+
+void SMeter::setGateValue(double value)
+{
+ gateValue = value;
+}
+
+void SMeter::setLongStep(double value)
+{
+ longStep = value;
+ update();
+}
+
+void SMeter::setShortStep(double value)
+{
+ shortStep = value;
+ update();
+}
+
+void SMeter::setPrecision(int value)
+{
+ precision = value;
+ update();
+}
+
+void SMeter::setValue(double value)
+{
+ currentValue = value;
+ update();
+}
+
+void SMeter::setValue(int value)
+{
+ setValue(double(value));
+}
+
+void SMeter::setTx(bool Tx)
+{
+ meterTx = Tx;
+}
diff --git a/smeter.h b/smeter.h
new file mode 100644
index 0000000..f35c0f3
--- /dev/null
+++ b/smeter.h
@@ -0,0 +1,73 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#ifndef SMETER_H
+#define SMETER_H
+
+#include
+
+class SMeter : public QWidget
+{
+ Q_OBJECT
+
+public:
+ explicit SMeter(QWidget *parent = nullptr);
+
+public slots:
+ void setMinValue(double value);
+ void setMaxValue(double value);
+ void setGateValue(double value);
+ void setLongStep(double value);
+ void setShortStep(double value);
+ void setPrecision(int value);
+
+ void setValue(double value);
+ void setValue(int value);
+
+ void setTx(bool Tx);
+
+protected:
+ void paintEvent(QPaintEvent *);
+ void drawMeter(QPainter *painter);
+ void drawProgress(QPainter *painter);
+ void drawScaleSMeter(QPainter *painter);
+ void drawScalePWRMeter(QPainter *painter);
+
+private:
+ double minValue; //Minimum scale value
+ double maxValue; //Maximum scale value
+ double gateValue; //Gate value to bar color change
+ double longStep; //Long lines with equal steps
+ double shortStep; //Short lines with equal steps
+ int precision; //Precision, the last few decimal places
+
+ double value; //target value
+ double currentValue; //current value
+
+ bool meterTx; //Switch between SMeter or PowerMeter
+
+ QColor bgColor; //background color
+ QColor lineColor; //line color
+ QColor progressColor; //progress color
+
+signals:
+
+};
+
+#endif // SMETER_H
diff --git a/submeter.cpp b/submeter.cpp
new file mode 100644
index 0000000..e37a886
--- /dev/null
+++ b/submeter.cpp
@@ -0,0 +1,257 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#include "submeter.h"
+#include
+#include
+#include
+
+SubMeter::SubMeter(QWidget *parent) : QWidget(parent)
+{
+ lineColor = QColor(Qt::black);
+ bgColor = QColor(Qt::white);
+ progressColor = QColor(Qt::green);
+
+ //Default value
+ minValue = 0;
+ maxValue = 10;
+ gateValue = 10;
+ longStep = 5;
+ shortStep = 1;
+ precision = 0;
+
+ meterSWR = 0;
+
+ currentValue = 0;
+}
+
+void SubMeter::paintEvent(QPaintEvent *)
+{
+ QPainter painter(this);
+ painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
+
+ QFont font;
+ font = painter.font();
+ font.setPointSize(font.pointSize() - 2);
+ painter.setFont(font);
+
+ drawMeter(&painter);
+ drawProgress(&painter);
+ drawScale(&painter);
+}
+
+void SubMeter::drawMeter(QPainter *painter)
+{
+ painter->save();
+ QPen pen(lineColor, 1, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin);
+ painter->setPen(pen);
+ painter->setBrush(bgColor);
+ painter->drawRect(0, height()/3+2, width()-12, height()/3-4);
+ painter->restore();
+}
+
+void SubMeter::drawProgress(QPainter *painter)
+{
+ painter->save();
+ painter->setPen(Qt::NoPen);
+ painter->setBrush(progressColor);
+
+ double length = width()-14;
+ double increment;
+
+ double initX, initXX;
+
+ if (meterSWR) increment = length / (10 * log10(maxValue));
+ else increment = length / (maxValue - minValue);
+
+ if (currentValue>gateValue)
+ {
+ if (currentValue > maxValue) currentValue = maxValue; //Trim value if overload scale
+
+ if (meterSWR) initX = 10 * log10(gateValue) * increment;
+ else initX = (gateValue - minValue) * increment;
+ QRect rect(1, height()/3+2+1, initX, height()/3-4-2);
+ painter->drawRect(rect);
+
+ //Red bar
+ if (meterSWR)
+ {
+ if (currentValue > maxValue) currentValue = maxValue; //Trim value if overload scale
+ initXX = 10 * (log10(currentValue) - log10(gateValue)) * increment;
+ }
+ else
+ {
+ if (currentValue > maxValue) currentValue = maxValue; //Trim value if overload scale
+ initXX = (currentValue - gateValue) * increment;
+ }
+ QRect rect2(initX+1, height()/3+2+1, initXX+1, height()/3-4-2);
+ painter->setBrush(Qt::red);
+ painter->drawRect(rect2);
+ }
+ else
+ {
+ if (meterSWR) initX = 10 * log10(currentValue) * increment;
+ else initX = (currentValue - minValue) * increment;
+ QRect rect(1, height()/3+2+1, initX, height()/3-4-2);
+ painter->drawRect(rect);
+ }
+
+ painter->restore();
+}
+
+void SubMeter::drawScale(QPainter *painter)
+{
+ painter->save();
+ painter->setPen(lineColor);
+
+ double initX = 0;
+ double initTopY = height()*2/3-2;
+ double length = width()-12;
+ double increment;
+
+ int longLineLen = 6;
+ int shortLineLen = 3;
+
+ QFontMetrics meterFont(painter->font());
+ double textHeight = meterFont.height();
+
+ if (meterSWR) increment = length / (10 * log10(maxValue));
+ else increment = length / (maxValue - minValue);
+
+ if (meterSWR) //Draw SWR meter with log scale
+ {
+ double j = 1.0;
+ for (int i = 0; i <= 10; i++) //1.0 to 2.0
+ {
+ QPointF topPot = QPointF(initX, initTopY);
+ QPointF bottomPot;
+ if (abs(j - 1.5) < 0.01 || abs(j - 2.0) < 0.01)
+ {
+ bottomPot = QPointF(initX, initTopY + longLineLen);
+ QString strValue = QString::number(j, 'f', 1);
+ double textWidth = fontMetrics().horizontalAdvance(strValue);
+ QPointF textPot = QPointF(initX - textWidth / 2, initTopY + textHeight + longLineLen - 2);
+ painter->drawText(textPot, strValue);
+ }
+ else bottomPot = QPointF(initX, initTopY + shortLineLen);
+ painter->drawLine(topPot, bottomPot);
+ j +=0.1;
+ initX = 10 * log10(j) * increment;
+ }
+ for (int i = 11; i <= 25; i++) //2.1 to 3.5
+ {
+ QPointF topPot = QPointF(initX, initTopY);
+ QPointF bottomPot;
+ if (abs(j - 2.5) < 0.01 || abs(j - 3.0) < 0.01 || abs(j - 3.5) < 0.01)
+ {
+ bottomPot = QPointF(initX, initTopY + longLineLen);
+ QString strValue = QString::number(j, 'f', 1);
+ double textWidth = fontMetrics().horizontalAdvance(strValue);
+ QPointF textPot = QPointF(initX - textWidth / 2, initTopY + textHeight + longLineLen - 2);
+ painter->drawText(textPot, strValue);
+ painter->drawLine(topPot, bottomPot);
+ }
+ j +=0.1;
+ initX = 10 * log10(j) * increment;
+ }
+ }
+ else //Draw scale and scale values based on range values
+ {
+ int stepNumber = (maxValue - minValue) / shortStep;
+ for (int i = 0; i <= stepNumber; i++)
+ {
+ double j = i * shortStep + minValue;
+ if (fmod(j,longStep) == 0)
+ {
+ if (j == minValue) //Do not draw the first value
+ {
+ initX += increment * shortStep;
+ continue;
+ }
+ QPointF topPot = QPointF(initX, initTopY);
+ QPointF bottomPot = QPointF(initX, initTopY + longLineLen);
+ painter->drawLine(topPot, bottomPot);
+
+ QString strValue = QString("%1").arg(j, 0, 'f', precision);
+ double textWidth = fontMetrics().horizontalAdvance(strValue);
+ QPointF textPot = QPointF(initX - textWidth / 2, initTopY + textHeight + longLineLen - 2);
+ painter->drawText(textPot, strValue);
+ }
+ else
+ {
+ QPointF topPot = QPointF(initX, initTopY);
+ QPointF bottomPot = QPointF(initX, initTopY + shortLineLen);
+ painter->drawLine(topPot, bottomPot);
+ }
+ initX += increment * shortStep;
+ }
+ }
+ painter->restore();
+}
+
+void SubMeter::setMinValue(double value)
+{
+ minValue = value;
+ update();
+}
+
+void SubMeter::setMaxValue(double value)
+{
+ maxValue = value;
+ update();
+}
+
+void SubMeter::setGateValue(double value)
+{
+ gateValue = value;
+}
+
+void SubMeter::setLongStep(double value)
+{
+ longStep = value;
+ update();
+}
+
+void SubMeter::setShortStep(double value)
+{
+ shortStep = value;
+ update();
+}
+
+void SubMeter::setPrecision(int value)
+{
+ precision = value;
+ update();
+}
+
+void SubMeter::setValue(double value)
+{
+ currentValue = value;
+ update();
+}
+
+void SubMeter::setValue(int value)
+{
+ setValue(double(value));
+}
+
+void SubMeter::setMeterSWR(bool swr)
+{
+ meterSWR = swr;
+}
diff --git a/submeter.h b/submeter.h
new file mode 100644
index 0000000..a4e1b29
--- /dev/null
+++ b/submeter.h
@@ -0,0 +1,71 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#ifndef SUBMETER_H
+#define SUBMETER_H
+
+#include
+
+class SubMeter : public QWidget
+{
+ Q_OBJECT
+public:
+ explicit SubMeter(QWidget *parent = nullptr);
+
+public slots:
+ void setMinValue(double value);
+ void setMaxValue(double value);
+ void setGateValue(double value);
+ void setLongStep(double value);
+ void setShortStep(double value);
+ void setPrecision(int value);
+
+ void setValue(double value);
+ void setValue(int value);
+
+ void setMeterSWR(bool swr);
+
+protected:
+ void paintEvent(QPaintEvent *);
+ void drawMeter(QPainter *painter);
+ void drawProgress(QPainter *painter);
+ void drawScale(QPainter *painter);
+
+private:
+ double minValue; //Minimum scale value
+ double maxValue; //Maximum scale value
+ double gateValue; //Gate value to bar color change
+ double longStep; //Long lines with equal steps
+ double shortStep; //Short lines with equal steps
+ int precision; //Precision, the last few decimal places
+
+ int meterSWR; //set for SWR meter
+
+ double value; //target value
+ double currentValue; //current value
+
+ QColor bgColor; //background color
+ QColor lineColor; //line color
+ QColor progressColor; //progress color
+
+signals:
+
+};
+
+#endif // SUBMETER_H
diff --git a/vfodisplay.cpp b/vfodisplay.cpp
new file mode 100644
index 0000000..c71ab03
--- /dev/null
+++ b/vfodisplay.cpp
@@ -0,0 +1,154 @@
+/**
+ ** This file is part of the CatRadio project.
+ ** Copyright 2022 Gianfranco Sordetti IZ8EWD .
+ **
+ ** This program is free software: you can redistribute it and/or modify
+ ** it under the terms of the GNU General Public License as published by
+ ** the Free Software Foundation, either version 3 of the License, or
+ ** (at your option) any later version.
+ **
+ ** This program is distributed in the hope that it will be useful,
+ ** but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ** GNU General Public License for more details.
+ **
+ ** You should have received a copy of the GNU General Public License
+ ** along with this program. If not, see .
+ **/
+
+
+#include "vfodisplay.h"
+#include "guidata.h"
+
+#include
+#include
+#include
+#include
+#include
+
+
+extern guiConfig guiConf;
+
+
+vfoDisplay::vfoDisplay(QWidget *parent) : QWidget(parent)
+{
+ lineColor = QColor(Qt::black);
+ bgColor = QColor(Qt::white);
+ textColor = QColor(Qt::black);
+}
+
+void vfoDisplay::paintEvent(QPaintEvent *)
+{
+ //setMouseTracking(true);
+
+ QPainter painter(this);
+ painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
+
+ QFont font;
+ font = painter.font();
+ font.setPointSize(height() - 18);
+ painter.setFont(font);
+
+ drawDisplay(&painter);
+ drawText(&painter);
+}
+
+void vfoDisplay::drawDisplay(QPainter *painter)
+{
+ painter->save();
+
+ QPen pen(lineColor, 1, Qt::SolidLine, Qt::SquareCap, Qt::MiterJoin);
+ painter->setPen(pen);
+ painter->setBrush(bgColor);
+ painter->drawRect(1, 1, width()-3, height()-2);
+ painter->restore();
+}
+
+void vfoDisplay::drawText(QPainter *painter)
+{
+ painter->save();
+ painter->setPen(textColor);
+
+ QFontMetrics meterFont(painter->font());
+ double textHeight = meterFont.ascent();
+ textWidth = meterFont.horizontalAdvance("0",-1);
+
+ QPointF textPot;
+
+ long val = currentValue;
+
+ for (int i = 1; i < 10; i++)
+ {
+ val = qFloor(val/10);
+ int d = val % 10;
+
+ if (i==2)
+ {
+ textPot = QPointF(width()-3-(textWidth+2)*i-4, textHeight);
+ painter->drawText(textPot, ".");
+ }
+
+ textPot = QPointF(width()-3-(textWidth+2)*i, textHeight);
+
+ if (val==0 && d==0) painter->drawText(textPot, " ");
+ else painter->drawText(textPot, QString::number(d));
+ }
+
+ painter->restore();
+}
+
+void vfoDisplay::setValue(unsigned long value)
+{
+ currentValue = value;
+ update();
+}
+
+//* Tuning using mouse buttons
+void vfoDisplay::mousePressEvent(QMouseEvent *event)
+{
+ event->accept();
+
+ QPoint pointerPos = event->pos();
+
+ for (int i = 1; i < 10; i ++)
+ {
+ if (pointerPos.x() > (width()-3-(textWidth+2)*i+1) && pointerPos.x() < (width()-3-(textWidth+2)*(i-1)-1))
+ {
+ if (guiConf.vfoDisplayMode && event->button() == Qt::LeftButton) //Up/Down mode
+ {
+ if (pointerPos.y() < height()/2) currentValue = currentValue + pow(10,i); //Up
+ else if (currentValue - pow(10,i) > 0) currentValue = currentValue - pow(10,i); //Down
+ }
+ else if (!guiConf.vfoDisplayMode) //Left/Right mode
+ {
+ if (event->button() == Qt::LeftButton) currentValue = currentValue + pow(10,i); //LeftButton
+ else if (currentValue - pow(10,i) > 0) currentValue = currentValue - pow(10,i); //RightButton
+ }
+
+ break;
+ }
+ }
+
+ update();
+ emit on_valueChanged(currentValue);
+}
+
+//* Tuning using mouse wheel
+void vfoDisplay::wheelEvent(QWheelEvent *event)
+{
+ event->accept();
+
+ QPointF pointerPos = event->position();
+
+ for (int i = 1; i < 10; i ++)
+ {
+ if (pointerPos.x() > (width()-3-(textWidth+2)*i+1) && pointerPos.x() < (width()-3-(textWidth+2)*(i-1)-1))
+ {
+ if (event->angleDelta().y() > 0) currentValue = currentValue + pow(10,i); //Wheel up
+ else if (currentValue - pow(10,i) > 0) currentValue = currentValue - pow(10,i); //Wheel down
+ }
+ }
+
+ update();
+ emit on_valueChanged(currentValue);
+}
diff --git a/vfodisplay.h b/vfodisplay.h
new file mode 100644
index 0000000..9dee447
--- /dev/null
+++ b/vfodisplay.h
@@ -0,0 +1,37 @@
+#ifndef VFODISPLAY_H
+#define VFODISPLAY_H
+
+#include
+
+class vfoDisplay : public QWidget
+{
+ Q_OBJECT
+
+public:
+ explicit vfoDisplay(QWidget *parent = nullptr);
+
+public slots:
+ void setValue(unsigned long value);
+
+signals:
+ void on_valueChanged(int value);
+
+protected:
+ void paintEvent(QPaintEvent *);
+ void drawDisplay(QPainter *painter);
+ void drawText(QPainter *painter);
+ void mousePressEvent(QMouseEvent *event); //Mouse buttons
+ void wheelEvent(QWheelEvent *event); //Mouse wheel
+
+private:
+ QColor bgColor; //background color
+ QColor lineColor; //line color
+ QColor textColor; //text color
+
+ unsigned long currentValue; //current frequency value (Hz)
+ unsigned long value; //target value
+
+ int textWidth; //number width
+};
+
+#endif // VFODISPLAY_H