You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
507 lines
20 KiB
507 lines
20 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2020 Jon Beniston, M7RCE // |
|
// // |
|
// 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 as 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 V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include "rigctrl.h" |
|
|
|
#include <QDebug> |
|
#include <QThread> |
|
#include <QtNetwork> |
|
|
|
// Length of buffers |
|
#define CMD_LENGTH 1024 |
|
#define URL_LENGTH 1024 |
|
#define RESPONSE_LENGTH 1024 |
|
#define DATA_LENGTH 1024 |
|
|
|
// Hamlib rigctrl error codes |
|
enum rig_errcode_e { |
|
RIG_OK = 0, /*!< No error, operation completed successfully */ |
|
RIG_EINVAL = -1, /*!< invalid parameter */ |
|
RIG_ECONF = -2, /*!< invalid configuration (serial,..) */ |
|
RIG_ENOMEM = -3, /*!< memory shortage */ |
|
RIG_ENIMPL = -4, /*!< function not implemented, but will be */ |
|
RIG_ETIMEOUT = -5, /*!< communication timed out */ |
|
RIG_EIO = -6, /*!< IO error, including open failed */ |
|
RIG_EINTERNAL = -7, /*!< Internal Hamlib error, huh! */ |
|
RIG_EPROTO = -8, /*!< Protocol error */ |
|
RIG_ERJCTED = -9, /*!< Command rejected by the rig */ |
|
RIG_ETRUNC = -10, /*!< Command performed, but arg truncated */ |
|
RIG_ENAVAIL = -11, /*!< function not available */ |
|
RIG_ENTARGET = -12, /*!< VFO not targetable */ |
|
RIG_BUSERROR = -13, /*!< Error talking on the bus */ |
|
RIG_BUSBUSY = -14, /*!< Collision on the bus */ |
|
RIG_EARG = -15, /*!< NULL RIG handle or any invalid pointer parameter in get arg */ |
|
RIG_EVFO = -16, /*!< Invalid VFO */ |
|
RIG_EDOM = -17 /*!< Argument out of domain of func */ |
|
}; |
|
|
|
// Map rigctrl mode names to SDRangel modem names |
|
const static struct mode_demod { |
|
const char *mode; |
|
const char *modem; |
|
} mode_map[] = { |
|
{"FM", "NFMDemod"}, |
|
{"WFM", "WFMDemod"}, |
|
{"AM", "AMDemod"}, |
|
{"LSB", "SSBDemod"}, |
|
{"USB", "SSBDemod"}, |
|
{nullptr, nullptr} |
|
}; |
|
|
|
// Get double value from within nested JSON object |
|
static double getSubObjectDouble(QJsonObject &json, const QString &key) |
|
{ |
|
double value = -1.0; |
|
|
|
for (QJsonObject::const_iterator it = json.begin(); it != json.end(); it++) { |
|
QJsonValue jsonValue = it.value(); |
|
if (jsonValue.isObject()) { |
|
QJsonObject settings = jsonValue.toObject(); |
|
if (settings.contains(key)) { |
|
value = settings[key].toDouble(); |
|
return value; |
|
} |
|
} |
|
} |
|
|
|
return value; |
|
} |
|
|
|
// Set double value withing nested JSON object |
|
static bool setSubObjectDouble(QJsonObject &json, const QString &key, double value) |
|
{ |
|
for (QJsonObject::iterator it = json.begin(); it != json.end(); it++) { |
|
QJsonValue jsonValue = it.value(); |
|
if (jsonValue.isObject()) { |
|
QJsonObject settings = jsonValue.toObject(); |
|
if (settings.contains(key)) { |
|
settings[key] = value; |
|
it.value() = settings; |
|
return true; |
|
} |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
RigCtrl::RigCtrl() : |
|
m_settings(), |
|
m_state(idle), |
|
m_tcpServer(nullptr), |
|
m_clientConnection(nullptr) |
|
{ |
|
m_netman = new QNetworkAccessManager(this); |
|
connect(m_netman, &QNetworkAccessManager::finished, this, &RigCtrl::processAPIResponse); |
|
|
|
setSettings(&m_settings); |
|
} |
|
|
|
RigCtrl::~RigCtrl() |
|
{ |
|
if (m_clientConnection != nullptr) { |
|
m_clientConnection->close(); |
|
delete m_clientConnection; |
|
} |
|
if (m_tcpServer != nullptr) { |
|
m_tcpServer->close(); |
|
delete m_tcpServer; |
|
} |
|
delete m_netman; |
|
} |
|
|
|
void RigCtrl::getSettings(RigCtrlSettings *settings) |
|
{ |
|
*settings = m_settings; |
|
} |
|
|
|
// Is there a potential for this to be called while in getCommand or processAPIResponse? |
|
void RigCtrl::setSettings(RigCtrlSettings *settings) |
|
{ |
|
bool disabled = (!settings->m_enabled) && m_settings.m_enabled; |
|
bool enabled = settings->m_enabled && !m_settings.m_enabled; |
|
bool portChanged = settings->m_rigCtrlPort != m_settings.m_rigCtrlPort; |
|
|
|
if (disabled || portChanged) { |
|
if (m_clientConnection != nullptr) { |
|
m_clientConnection->close(); |
|
delete m_clientConnection; |
|
m_clientConnection = nullptr; |
|
} |
|
if (m_tcpServer != nullptr) { |
|
m_tcpServer->close(); |
|
delete m_tcpServer; |
|
m_tcpServer = nullptr; |
|
} |
|
} |
|
|
|
if (enabled || portChanged) { |
|
qDebug() << "RigCtrl enabled on port " << settings->m_rigCtrlPort; |
|
m_tcpServer = new QTcpServer(this); |
|
if(!m_tcpServer->listen(QHostAddress::Any, settings->m_rigCtrlPort)) { |
|
qDebug() << "RigCtrl failed to listen on port " << settings->m_rigCtrlPort << ". Check it is not already in use."; |
|
} else { |
|
connect(m_tcpServer, &QTcpServer::newConnection, this, &RigCtrl::acceptConnection); |
|
} |
|
} |
|
|
|
m_settings = *settings; |
|
} |
|
|
|
QByteArray RigCtrl::serialize() const |
|
{ |
|
return m_settings.serialize(); |
|
} |
|
|
|
bool RigCtrl::deserialize(const QByteArray& data) |
|
{ |
|
bool success = true; |
|
RigCtrlSettings settings; |
|
|
|
if (!settings.deserialize(data)) { |
|
success = false; |
|
} else { |
|
setSettings(&settings); |
|
} |
|
|
|
return success; |
|
} |
|
|
|
// Accept connection from rigctrl client |
|
void RigCtrl::acceptConnection() |
|
{ |
|
m_clientConnection = m_tcpServer->nextPendingConnection(); |
|
if (!m_clientConnection) { |
|
return; |
|
} |
|
connect(m_clientConnection, &QIODevice::readyRead, this, &RigCtrl::getCommand); |
|
connect(m_clientConnection, &QAbstractSocket::disconnected, m_clientConnection, &QObject::deleteLater); |
|
} |
|
|
|
// Get rigctrl command and start processing it |
|
void RigCtrl::getCommand() |
|
{ |
|
char cmd[CMD_LENGTH]; |
|
char url[URL_LENGTH]; |
|
char response[RESPONSE_LENGTH]; |
|
qint64 len; |
|
QNetworkRequest request; |
|
char *p; |
|
int i, l; |
|
|
|
// Get rigctrld command from client |
|
len = m_clientConnection->readLine(cmd, sizeof(cmd)); |
|
if (len != -1) { |
|
//qDebug() << "RigCtrl::getCommand - " << cmd; |
|
|
|
if (!strncmp(cmd, "F ", 2) || !strncmp(cmd, "set_freq ", 9)) { |
|
// Set frequency |
|
m_targetFrequency = atof(cmd[0] == 'F' ? &cmd[2] : &cmd[9]); |
|
// Get current centre frequency |
|
sprintf(url, "%s/deviceset/%d/device/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->get(request); |
|
m_state = set_freq; |
|
} else if (!strncmp(cmd, "f", 1) || !strncmp(cmd, "get_freq", 8)) { |
|
// Get frequency - need to add centerFrequency and inputFrequencyOffset |
|
sprintf(url, "%s/deviceset/%d/device/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->get(request); |
|
m_state = get_freq_center; |
|
} else if (!strncmp(cmd, "M ?", 3) || !(strncmp(cmd, "set_mode ?", 10))) { |
|
// Return list of modes supported |
|
p = response; |
|
for (i = 0; mode_map[i].mode != nullptr; i++) { |
|
p += sprintf(p, "%s ", mode_map[i].mode); |
|
} |
|
p += sprintf(p, "\n"); |
|
m_clientConnection->write(response, strlen(response)); |
|
} else if (!strncmp(cmd, "M ", 2) || !(strncmp(cmd, "set_mode ", 9))) { |
|
// Set mode |
|
// Map rigctrl mode name to SDRangel modem name |
|
m_targetModem = nullptr; |
|
m_targetBW = -1; |
|
p = cmd[0] == 'M' ? &cmd[2] : &cmd[9]; |
|
for (i = 0; mode_map[i].mode != nullptr; i++) { |
|
l = strlen(mode_map[i].mode); |
|
if (!strncmp(p, mode_map[i].mode, l)) { |
|
m_targetModem = mode_map[i].modem; |
|
p += l; |
|
break; |
|
} |
|
} |
|
// Save bandwidth, if given |
|
while(isspace(*p)) { |
|
p++; |
|
} |
|
if (*p == ',') { |
|
p++; |
|
m_targetBW = atoi(p); |
|
} |
|
if (mode_map[i].modem != nullptr) { |
|
// Delete current modem |
|
sprintf(url, "%s/deviceset/%d/channel/%d", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex, m_settings.m_channelIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->sendCustomRequest(request, "DELETE"); |
|
m_state = set_mode_mod; |
|
} else { |
|
sprintf(response, "RPRT %d\n", RIG_EINVAL); |
|
m_clientConnection->write(response, strlen(response)); |
|
} |
|
} else if (!strncmp(cmd, "set_powerstat 0", 15)) { |
|
// Power off radio |
|
sprintf(url, "%s/deviceset/%d/device/run", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->sendCustomRequest(request, "DELETE"); |
|
m_state = set_power_off; |
|
} else if (!strncmp(cmd, "set_powerstat 1", 15)) { |
|
// Power on radio |
|
sprintf(url, "%s/deviceset/%d/device/run", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->post(request, ""); |
|
m_state = set_power_on; |
|
} else if (!strncmp(cmd, "get_powerstat", 13)) { |
|
// Return if powered on or off |
|
sprintf(url, "%s/deviceset/%d/device/run", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->get(request); |
|
m_state = get_power; |
|
} else { |
|
// Unimplemented command |
|
sprintf(response, "RPRT %d\n", RIG_ENIMPL); |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
} |
|
} |
|
} |
|
|
|
// Process reply from SDRangel API server |
|
void RigCtrl::processAPIResponse(QNetworkReply *reply) |
|
{ |
|
double freq; |
|
char response[RESPONSE_LENGTH]; |
|
char url[URL_LENGTH]; |
|
char data[DATA_LENGTH]; |
|
QNetworkRequest request; |
|
|
|
if (reply->error() == QNetworkReply::NoError) { |
|
QString answer = reply->readAll(); |
|
//qDebug("RigCtrl::processAPIResponse - '%s'", qUtf8Printable(answer)); |
|
|
|
QJsonDocument jsonResponse = QJsonDocument::fromJson(answer.toUtf8()); |
|
QJsonObject jsonObj = jsonResponse.object(); |
|
|
|
switch (m_state) { |
|
|
|
case get_freq_center: |
|
// Reply with current center frequency |
|
freq = getSubObjectDouble(jsonObj, "centerFrequency"); |
|
if (freq >= 0.0) { |
|
m_targetFrequency = freq; |
|
sprintf(url, "%s/deviceset/%d/channel/%d/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex, m_settings.m_channelIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->get(request); |
|
} else { |
|
sprintf(response, "RPRT %d\n", RIG_ENIMPL); // File source doesn't have centre frequency |
|
} |
|
m_state = get_freq_offset; |
|
break; |
|
|
|
case get_freq_offset: |
|
freq = m_targetFrequency + getSubObjectDouble(jsonObj, "inputFrequencyOffset"); |
|
sprintf(response, "%u\n", (unsigned)freq); |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
break; |
|
|
|
case set_freq: |
|
// Check if target requency is within max offset from current center frequency |
|
freq = getSubObjectDouble(jsonObj, "centerFrequency"); |
|
if (fabs(freq - m_targetFrequency) > m_settings.m_maxFrequencyOffset) { |
|
// Update centerFrequency |
|
setSubObjectDouble(jsonObj, "centerFrequency", m_targetFrequency); |
|
sprintf(url, "%s/deviceset/%d/device/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->sendCustomRequest(request, "PATCH", QJsonDocument(jsonObj).toJson()); |
|
m_state = set_freq_center; |
|
} else { |
|
// In range, so update inputFrequencyOffset |
|
m_targetOffset = m_targetFrequency - freq; |
|
// Get settings containg inputFrequencyOffset, so we can patch them |
|
sprintf(url, "%s/deviceset/%d/channel/%d/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex, m_settings.m_channelIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->get(request); |
|
m_state = set_freq_set_offset; |
|
} |
|
break; |
|
|
|
case set_freq_no_offset: |
|
// Update centerFrequency, without trying to set offset |
|
setSubObjectDouble(jsonObj, "centerFrequency", m_targetFrequency); |
|
sprintf(url, "%s/deviceset/%d/device/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->sendCustomRequest(request, "PATCH", QJsonDocument(jsonObj).toJson()); |
|
m_state = set_freq_center_no_offset; |
|
break; |
|
|
|
case set_freq_center: |
|
// Check whether frequency was set as expected |
|
freq = getSubObjectDouble(jsonObj, "centerFrequency"); |
|
if (freq == m_targetFrequency) { |
|
// Set inputFrequencyOffset to 0 |
|
m_targetOffset = 0; |
|
sprintf(url, "%s/deviceset/%d/channel/%d/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex, m_settings.m_channelIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->get(request); |
|
m_state = set_freq_set_offset; |
|
} else { |
|
sprintf(response, "RPRT %d\n", RIG_EINVAL); |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
} |
|
break; |
|
|
|
case set_freq_center_no_offset: |
|
// Check whether frequency was set as expected |
|
freq = getSubObjectDouble(jsonObj, "centerFrequency"); |
|
if (freq == m_targetFrequency) { |
|
sprintf(response, "RPRT 0\n"); |
|
} else { |
|
sprintf(response, "RPRT %d\n", RIG_EINVAL); |
|
} |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
break; |
|
|
|
case set_freq_set_offset: |
|
// Patch inputFrequencyOffset |
|
if (setSubObjectDouble(jsonObj, "inputFrequencyOffset", m_targetOffset)) { |
|
sprintf(url, "%s/deviceset/%d/channel/%d/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex, m_settings.m_channelIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->sendCustomRequest(request, "PATCH", QJsonDocument(jsonObj).toJson()); |
|
m_state = set_freq_offset; |
|
} else { |
|
// No inputFrequencyOffset |
|
sprintf(response, "RPRT %d\n", RIG_EINVAL); |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
} |
|
break; |
|
|
|
case set_freq_offset: |
|
freq = getSubObjectDouble(jsonObj, "inputFrequencyOffset"); |
|
if (freq == m_targetOffset) { |
|
sprintf(response, "RPRT 0\n"); |
|
} else { |
|
sprintf(response, "RPRT %d\n", RIG_EINVAL); |
|
} |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
break; |
|
|
|
case set_mode_mod: |
|
// Create new modem |
|
sprintf(url, "%s/deviceset/%d/channel", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
sprintf(data, "{ \"channelType\": \"%s\", \"direction\": 0, \"originatorDeviceSetIndex\": %d}\n", m_targetModem, m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
request.setHeader(QNetworkRequest::ContentTypeHeader,"application/json"); |
|
m_netman->post(request, data); |
|
if (m_targetBW >= 0) { |
|
m_state = set_mode_settings; |
|
} else { |
|
m_state = set_mode_reply; |
|
} |
|
break; |
|
|
|
case set_mode_settings: |
|
// Set modem bandwidth |
|
sprintf(url, "%s/deviceset/%d/channel/%d/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex, m_settings.m_channelIndex); |
|
sprintf(data, "{ \"channelType\": \"%s\", \"%sSettings\": {\"rfBandwidth\":%d}}\n", m_targetModem, m_targetModem, m_targetBW); |
|
request.setUrl(QUrl(url)); |
|
request.setHeader(QNetworkRequest::ContentTypeHeader,"application/json"); |
|
m_netman->sendCustomRequest(request, "PATCH", data); |
|
m_state = set_mode_reply; |
|
break; |
|
|
|
case set_mode_reply: |
|
sprintf(response, "RPRT 0\n"); |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
break; |
|
|
|
case get_power: |
|
if (!jsonObj["state"].toString().compare("running")) { |
|
sprintf(response, "1\n"); |
|
} else { |
|
sprintf(response, "0\n"); |
|
} |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
break; |
|
|
|
case set_power_on: |
|
case set_power_off: |
|
// Reply contains previous state, not current state, so assume it worked |
|
sprintf(response, "RPRT 0\n"); |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
break; |
|
} |
|
|
|
} else { |
|
//qDebug("RigCtrl::processAPIResponse - got error: '%s'", qUtf8Printable(reply->errorString())); |
|
//qDebug() << reply->readAll(); |
|
|
|
switch (m_state) { |
|
case get_freq_offset: |
|
// Probably no modem enabled on the specified channel |
|
sprintf(response, "%u\n", (unsigned)m_targetFrequency); |
|
m_clientConnection->write(response, strlen(response)); |
|
m_state = idle; |
|
break; |
|
|
|
case set_freq_set_offset: |
|
// Probably no demodulator enabled on the specified channel |
|
// Just set as center frequency |
|
sprintf(url, "%s/deviceset/%d/device/settings", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
m_netman->get(request); |
|
m_state = set_freq_no_offset; |
|
break; |
|
|
|
case set_mode_mod: |
|
// Probably no modem on channel to delete, so continue to try to create one |
|
sprintf(url, "%s/deviceset/%d/channel", qUtf8Printable(m_settings.m_APIAddress), m_settings.m_deviceIndex); |
|
sprintf(data, "{ \"channelType\": \"%s\", \"direction\": 0, \"originatorDeviceSetIndex\": %d}\n", m_targetModem, m_settings.m_deviceIndex); |
|
request.setUrl(QUrl(url)); |
|
request.setHeader(QNetworkRequest::ContentTypeHeader,"application/json"); |
|
m_netman->post(request, data); |
|
if (m_targetBW >= 0) { |
|
m_state = set_mode_settings; |
|
} else { |
|
m_state = set_mode_reply; |
|
} |
|
break; |
|
|
|
default: |
|
sprintf(response, "RPRT %d\n", RIG_EIO); |
|
m_clientConnection->write(response, strlen(response)); |
|
break; |
|
} |
|
} |
|
|
|
reply->deleteLater(); |
|
}
|
|
|