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.
676 lines
28 KiB
676 lines
28 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Some code by AI // |
|
// // |
|
// 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 <QDebug> |
|
#include <QJsonArray> |
|
#include <QJsonDocument> |
|
#include <QCoreApplication> |
|
|
|
#include "mcpstreams.h" |
|
#include "mcpprotocol.h" |
|
|
|
const char* const MCPProtocol::m_serverName = "SDRangel"; |
|
const char* const MCPProtocol::m_latestProtocolVersion = "2025-06-18"; |
|
|
|
MCPProtocol::MCPProtocol(WebAPIAdapterInterface *webAPIAdapterInterface) : |
|
m_webAPIAdapterInterface(webAPIAdapterInterface), |
|
m_tools(webAPIAdapterInterface), |
|
m_streams(nullptr) |
|
{ |
|
} |
|
|
|
QJsonObject MCPProtocol::makeResult(const QJsonValue& id, const QJsonValue& result) |
|
{ |
|
QJsonObject response; |
|
response["jsonrpc"] = "2.0"; |
|
response["id"] = id; |
|
response["result"] = result; |
|
return response; |
|
} |
|
|
|
QJsonObject MCPProtocol::makeError(const QJsonValue& id, int code, const QString& message) |
|
{ |
|
QJsonObject error; |
|
error["code"] = code; |
|
error["message"] = message; |
|
QJsonObject response; |
|
response["jsonrpc"] = "2.0"; |
|
response["id"] = id.isUndefined() ? QJsonValue() : id; |
|
response["error"] = error; |
|
return response; |
|
} |
|
|
|
// JSON-RPC 2.0 rules: a message with an "id" member is a request and always gets a reply |
|
// carrying that id, even if the id is null (MCP forbids null ids but a client that sends one |
|
// must still learn what happened). A message with a method and no id is a notification and |
|
// gets no reply. Anything that is neither a valid request, notification nor response is |
|
// answered with an Invalid Request error whose id is null when it cannot be identified. |
|
bool MCPProtocol::handleMessage(const QJsonObject& message, QJsonObject& response, Context& context) |
|
{ |
|
bool hasId = message.contains("id"); |
|
QJsonValue id = hasId ? message["id"] : QJsonValue(); |
|
bool hasMethod = message["method"].isString() && !message["method"].toString().isEmpty(); |
|
|
|
if (!hasMethod) |
|
{ |
|
// A response to a server initiated request. We never send any, so there is nothing to do. |
|
if (hasId && (message.contains("result") || message.contains("error"))) { |
|
return false; |
|
} |
|
|
|
response = makeError(id, InvalidRequest, "Invalid request: missing method"); |
|
return true; |
|
} |
|
|
|
if (message["jsonrpc"].toString() != "2.0") |
|
{ |
|
response = makeError(id, InvalidRequest, "Invalid request: jsonrpc must be \"2.0\""); |
|
return true; |
|
} |
|
|
|
QString method = message["method"].toString(); |
|
QJsonObject params = message["params"].toObject(); |
|
|
|
try |
|
{ |
|
// Calls are serialized so that tool handlers never run concurrently, except for the |
|
// capture tools: those deliberately block for up to 30 seconds, and holding the lock |
|
// across one would stall every other request, including ping and the status calls a |
|
// client needs while a capture runs. They protect their own state instead. |
|
QJsonValue result; |
|
|
|
if (isLongRunning(method, params)) |
|
{ |
|
result = dispatch(method, params, context); |
|
} |
|
else |
|
{ |
|
QMutexLocker locker(&m_mutex); |
|
result = dispatch(method, params, context); |
|
} |
|
|
|
if (!hasId) { |
|
return false; // notification: no reply |
|
} |
|
|
|
response = makeResult(id, result); |
|
return true; |
|
} |
|
catch (const MCPError& e) |
|
{ |
|
qDebug() << "MCPProtocol::handleMessage:" << method << "error:" << e.code << e.message; |
|
|
|
if (!hasId) { |
|
return false; |
|
} |
|
|
|
response = makeError(id, e.code, e.message); |
|
return true; |
|
} |
|
catch (const MCPToolError& e) |
|
{ |
|
// A tool level failure raised outside tools/call: resources/read shares the tool |
|
// helpers, and a resource that is not there (a device set index that does not exist, |
|
// an unknown schema type) surfaces here. Left uncaught it would leave the HTTP thread |
|
// and take the application down, since MCPToolError is not a std::exception |
|
qDebug() << "MCPProtocol::handleMessage:" << method << "error:" << e.message; |
|
|
|
if (!hasId) { |
|
return false; |
|
} |
|
|
|
response = makeError(id, method.startsWith("resources/") ? ResourceNotFound : InvalidParams, e.message); |
|
return true; |
|
} |
|
catch (const std::exception& e) |
|
{ |
|
qWarning() << "MCPProtocol::handleMessage:" << method << "exception:" << e.what(); |
|
|
|
if (!hasId) { |
|
return false; |
|
} |
|
|
|
response = makeError(id, InternalError, QString("Internal error: %1").arg(e.what())); |
|
return true; |
|
} |
|
catch (...) |
|
{ |
|
// Nothing thrown here may reach the connection thread, which has no handler |
|
qWarning() << "MCPProtocol::handleMessage:" << method << "unknown exception"; |
|
|
|
if (!hasId) { |
|
return false; |
|
} |
|
|
|
response = makeError(id, InternalError, "Internal error"); |
|
return true; |
|
} |
|
} |
|
|
|
// The capture tools sleep for the requested duration, so they run without the dispatch lock. |
|
// MCPCapture and MCPAudioCapture each serialize their own work, and everything they call |
|
// through the Web API adapter is safe to use from several threads. |
|
bool MCPProtocol::isLongRunning(const QString& method, const QJsonObject& params) |
|
{ |
|
if (method != "tools/call") { |
|
return false; |
|
} |
|
|
|
static const QStringList blocking = {"record_iq", "capture_audio", "listen", "scan"}; |
|
return blocking.contains(params["name"].toString()); |
|
} |
|
|
|
QJsonValue MCPProtocol::dispatch(const QString& method, const QJsonObject& params, Context& context) |
|
{ |
|
if (method == "initialize") { |
|
return initialize(params, context); |
|
} else if (method == "ping") { |
|
return QJsonObject(); |
|
} else if (method.startsWith("notifications/")) { |
|
return QJsonValue(); // initialized, cancelled, progress, roots/list_changed: nothing to do |
|
} else if (method == "tools/list") { |
|
return toolsList(params); |
|
} else if (method == "tools/call") { |
|
return toolsCall(params); |
|
} else if (method == "resources/list") { |
|
return resourcesList(params); |
|
} else if (method == "resources/templates/list") { |
|
return resourcesTemplatesList(params); |
|
} else if (method == "resources/read") { |
|
return resourcesRead(params); |
|
} else if (method == "resources/subscribe") { |
|
return resourcesSubscribe(params, context, true); |
|
} else if (method == "resources/unsubscribe") { |
|
return resourcesSubscribe(params, context, false); |
|
} else if (method == "prompts/list") { |
|
return promptsList(params); |
|
} else if (method == "prompts/get") { |
|
return promptsGet(params); |
|
} else if (method == "logging/setLevel") { |
|
return QJsonObject(); |
|
} else if (method == "completion/complete") { |
|
QJsonObject completion; |
|
completion["values"] = QJsonArray(); |
|
completion["hasMore"] = false; |
|
QJsonObject result; |
|
result["completion"] = completion; |
|
return result; |
|
} else { |
|
throw MCPError(MethodNotFound, QString("Method not found: %1").arg(method)); |
|
} |
|
} |
|
|
|
// Protocol revisions this server implements, newest first. 2024-11-05 is deliberately absent: |
|
// it specifies the two endpoint HTTP+SSE transport, with a separate message endpoint announced |
|
// by an initial endpoint event, and this server only implements Streamable HTTP. |
|
QStringList MCPProtocol::supportedVersions() |
|
{ |
|
return QStringList{"2025-06-18", "2025-03-26"}; |
|
} |
|
|
|
bool MCPProtocol::isSupportedVersion(const QString& version) |
|
{ |
|
return supportedVersions().contains(version); |
|
} |
|
|
|
QJsonValue MCPProtocol::initialize(const QJsonObject& params, Context& context) |
|
{ |
|
// Echo the client's version if we implement it, otherwise offer the newest we have |
|
QString requested = params["protocolVersion"].toString(); |
|
QString version = isSupportedVersion(requested) ? requested : QString(m_latestProtocolVersion); |
|
|
|
QJsonObject clientInfo = params["clientInfo"].toObject(); |
|
qInfo("MCPProtocol::initialize: client %s %s protocol %s", |
|
qPrintable(clientInfo["name"].toString()), |
|
qPrintable(clientInfo["version"].toString()), |
|
qPrintable(requested)); |
|
|
|
QJsonObject tools; |
|
tools["listChanged"] = false; |
|
QJsonObject resources; |
|
resources["subscribe"] = true; |
|
resources["listChanged"] = false; |
|
QJsonObject prompts; |
|
prompts["listChanged"] = false; |
|
QJsonObject capabilities; |
|
capabilities["tools"] = tools; |
|
capabilities["resources"] = resources; |
|
capabilities["prompts"] = prompts; |
|
|
|
QJsonObject serverInfo; |
|
serverInfo["name"] = m_serverName; |
|
serverInfo["title"] = "SDRangel SDR"; |
|
serverInfo["version"] = qApp->applicationVersion(); |
|
|
|
// A session lets subscriptions and the event stream of this client be told apart from |
|
// those of any other. Clients that ignore the session id share an anonymous one. |
|
if (m_streams) { |
|
context.m_newSessionId = m_streams->createSession(); |
|
} |
|
|
|
QJsonObject result; |
|
result["protocolVersion"] = version; |
|
result["capabilities"] = capabilities; |
|
result["serverInfo"] = serverInfo; |
|
result["instructions"] = instructions(); |
|
return result; |
|
} |
|
|
|
// resources/subscribe and resources/unsubscribe. Updates are delivered as |
|
// notifications/resources/updated on the SSE stream opened with GET. |
|
QJsonValue MCPProtocol::resourcesSubscribe(const QJsonObject& params, Context& context, bool subscribe) |
|
{ |
|
QString uri = params["uri"].toString(); |
|
|
|
if (uri.isEmpty()) { |
|
throw MCPError(InvalidParams, "Invalid params: missing uri"); |
|
} |
|
|
|
if (!m_streams) { |
|
throw MCPError(InternalError, "Subscriptions are not available"); |
|
} |
|
|
|
// Only the resources that change are worth subscribing to |
|
static const QStringList subscribable = { |
|
"sdrangel://instance", "sdrangel://packets", "sdrangel://map/items" |
|
}; |
|
|
|
if (subscribe && !subscribable.contains(uri) && !uri.startsWith("sdrangel://deviceset/")) |
|
{ |
|
throw MCPError(InvalidParams, QString("Resource %1 does not change, so it cannot be subscribed to. " |
|
"Subscribable resources are %2 and sdrangel://deviceset/{index}").arg(uri).arg(subscribable.join(", "))); |
|
} |
|
|
|
// A device set URI has to name one that could exist: the index the Web API accepts is two |
|
// digits, so anything else is a mistake rather than a resource to watch for |
|
if (subscribe && uri.startsWith("sdrangel://deviceset/")) |
|
{ |
|
static const QRegularExpression deviceSetUri("^sdrangel://deviceset/([0-9]{1,2})$"); |
|
|
|
if (!deviceSetUri.match(uri).hasMatch()) { |
|
throw MCPError(InvalidParams, QString("Resource %1 is not a device set: use sdrangel://deviceset/{index} with an index from 0 to 99").arg(uri)); |
|
} |
|
} |
|
|
|
if (subscribe) |
|
{ |
|
if (!m_streams->subscribe(context.m_sessionId, uri)) { |
|
throw MCPError(InvalidParams, QString("This session already has %1 subscriptions; unsubscribe from one first").arg(MCPStreams::m_maxSubscriptions)); |
|
} |
|
} |
|
else |
|
{ |
|
m_streams->unsubscribe(context.m_sessionId, uri); |
|
} |
|
|
|
return QJsonObject(); |
|
} |
|
|
|
QString MCPProtocol::instructions() |
|
{ |
|
return |
|
"SDRangel is a software defined radio (SDR) application. This server controls a running SDRangel instance.\n" |
|
"\n" |
|
"Start with the intent tools: listen (receive a frequency in a mode, one call) and scan (find and follow activity across " |
|
"frequencies). get_status is the cheapest view of what is running. Use the object level tools to adjust what they set up.\n" |
|
"\n" |
|
"Object model: a device set (R0, R1... for receivers, T0... for transmitters) holds one sampling device (an SDR such as an " |
|
"RTL-SDR) and any number of channels (demodulators/modulators) processing its baseband. Device settings include centerFrequency " |
|
"(Hz), sample rate and gain; channel settings include inputFrequencyOffset (Hz from the device centre). Features are device " |
|
"independent plugins (Map, AIS, APRS...) in the single feature set (index 0).\n" |
|
"\n" |
|
"Settings keys are specific to each type, but the common ones (centerFrequency, inputFrequencyOffset, rfBandwidth, squelch, " |
|
"volume, gain) can be set straight away: a set_* tool applies what it recognises, replies with just the keys changed, and names " |
|
"any it did not recognise. Call describe_settings only for an unfamiliar key or when you need its range. get_receiving_guide " |
|
"says which demodulator, frequency and sample rate a named signal needs; get_docs has a plugin's full readme, by section.\n" |
|
"\n" |
|
"A receiver's baseband rate (for RTL-SDR, devSampleRate / 2^log2Decim) must exceed every channel's RF bandwidth; listen " |
|
"chooses it for you, and get_channel_report shows the resulting channelSampleRate.\n" |
|
"\n" |
|
"Recording: record_iq writes baseband IQ for a fixed time, start_iq_recording/stop_iq_recording for longer; capture_audio " |
|
"writes a demodulator's audio to WAV and says whether it was silent. Files go under the capture directory shown by " |
|
"get_server_status. Live data: get_packets (AIS, APRS, LoRa, M17, Meshtastic, Inmarsat, radiosondes) and get_map_items " |
|
"(aircraft, ships, sondes, satellites) return what running plugins have decoded.\n" |
|
"\n" |
|
"Frequencies are in Hz. Direction is \"rx\" or \"tx\". Creation tools wait for SDRangel to finish and return the new index; " |
|
"setting changes are applied asynchronously."; |
|
} |
|
|
|
QJsonValue MCPProtocol::toolsList(const QJsonObject& params) |
|
{ |
|
(void) params; |
|
QJsonObject result; |
|
result["tools"] = m_tools.listTools(); |
|
return result; |
|
} |
|
|
|
QJsonValue MCPProtocol::toolsCall(const QJsonObject& params) |
|
{ |
|
QString name = params["name"].toString(); |
|
|
|
if (name.isEmpty()) { |
|
throw MCPError(InvalidParams, "Invalid params: missing tool name"); |
|
} |
|
|
|
return m_tools.callTool(name, params["arguments"].toObject()); |
|
} |
|
|
|
QJsonObject MCPProtocol::textContent(const QString& text) |
|
{ |
|
QJsonObject content; |
|
content["type"] = "text"; |
|
content["text"] = text; |
|
return content; |
|
} |
|
|
|
struct MCPResourceDef { |
|
const char *uri; |
|
const char *name; |
|
const char *description; |
|
}; |
|
|
|
static const MCPResourceDef staticResources[] = { |
|
{"sdrangel://instance", "Instance summary", "Version, device sets with their devices and channels, and features currently configured"}, |
|
{"sdrangel://plugins/devices", "Available sampling devices", "SDR hardware (and software sources/sinks) that can be selected in a device set"}, |
|
{"sdrangel://plugins/channels", "Available channel types", "Demodulator and modulator plugins that can be added to a device set"}, |
|
{"sdrangel://plugins/features", "Available feature types", "Feature plugins that can be added to the feature set"}, |
|
{"sdrangel://presets", "Presets", "Saved device set presets (device and channel settings) grouped by name"}, |
|
{"sdrangel://configurations", "Configurations", "Saved whole-instance configurations grouped by name"}, |
|
{"sdrangel://guide", "Receiving guide", "Which demodulator and frequency to use for a given signal, the minimum sample rate some modes need, and why nothing is received"}, |
|
{"sdrangel://docs", "Documentation index", "Documentation available for the devices, channels and features registered in this instance, and for GUI pages such as the spectrum display, with section headings"}, |
|
{"sdrangel://packets", "Recent packets", "The most recent packets decoded by AIS, packet (AX.25/APRS), LoRa, M17, Meshtastic, MeshCore, Inmarsat and radiosonde demodulators"}, |
|
{"sdrangel://map/items", "Map items", "Objects currently plotted on the map: aircraft, ships, APRS stations, radiosondes, satellites, beacons"}, |
|
}; |
|
|
|
QJsonValue MCPProtocol::resourcesList(const QJsonObject& params) |
|
{ |
|
(void) params; |
|
QJsonArray resources; |
|
|
|
for (const auto& def : staticResources) |
|
{ |
|
QJsonObject resource; |
|
resource["uri"] = def.uri; |
|
resource["name"] = def.name; |
|
resource["description"] = def.description; |
|
resource["mimeType"] = "application/json"; |
|
resources.append(resource); |
|
} |
|
|
|
QJsonObject result; |
|
result["resources"] = resources; |
|
return result; |
|
} |
|
|
|
QJsonValue MCPProtocol::resourcesTemplatesList(const QJsonObject& params) |
|
{ |
|
(void) params; |
|
QJsonArray templates; |
|
|
|
QJsonObject schema; |
|
schema["uriTemplate"] = "sdrangel://schema/{type}"; |
|
schema["name"] = "Settings schema"; |
|
schema["description"] = "Documentation of the settings, report and actions keys for a device (hardware id such as RTLSDR), channel (type such as ADSBDemod) or feature (type such as Map)"; |
|
schema["mimeType"] = "text/plain"; |
|
templates.append(schema); |
|
|
|
QJsonObject deviceset; |
|
deviceset["uriTemplate"] = "sdrangel://deviceset/{deviceSetIndex}"; |
|
deviceset["name"] = "Device set"; |
|
deviceset["description"] = "Sampling device and channels of a device set"; |
|
deviceset["mimeType"] = "application/json"; |
|
templates.append(deviceset); |
|
|
|
QJsonObject docs; |
|
docs["uriTemplate"] = "sdrangel://docs/{kind}/{id}"; |
|
docs["name"] = "Plugin documentation"; |
|
docs["description"] = "User documentation (readme) of a plugin: kind is device, channel or feature and id is the type id (e.g. channel/ADSBDemod, device/RTLSDR, feature/Map)"; |
|
docs["mimeType"] = "text/markdown"; |
|
templates.append(docs); |
|
|
|
QJsonObject result; |
|
result["resourceTemplates"] = templates; |
|
return result; |
|
} |
|
|
|
QJsonValue MCPProtocol::resourcesRead(const QJsonObject& params) |
|
{ |
|
QString uri = params["uri"].toString(); |
|
QJsonObject content; |
|
content["uri"] = uri; |
|
|
|
if (uri == "sdrangel://instance") |
|
{ |
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.getInstanceSummary()).toJson(QJsonDocument::Compact)); |
|
} |
|
else if (uri == "sdrangel://plugins/devices") |
|
{ |
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.getAvailableDevices()).toJson(QJsonDocument::Compact)); |
|
} |
|
else if (uri == "sdrangel://plugins/channels") |
|
{ |
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.getAvailableChannels()).toJson(QJsonDocument::Compact)); |
|
} |
|
else if (uri == "sdrangel://plugins/features") |
|
{ |
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.getAvailableFeatures()).toJson(QJsonDocument::Compact)); |
|
} |
|
else if (uri == "sdrangel://presets") |
|
{ |
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.getPresets()).toJson(QJsonDocument::Compact)); |
|
} |
|
else if (uri == "sdrangel://configurations") |
|
{ |
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.getConfigurations()).toJson(QJsonDocument::Compact)); |
|
} |
|
else if (uri.startsWith("sdrangel://schema/")) |
|
{ |
|
content["mimeType"] = "text/plain"; |
|
content["text"] = m_tools.describeType(uri.mid(QString("sdrangel://schema/").size()), ""); |
|
} |
|
else if (uri == "sdrangel://guide") |
|
{ |
|
content["mimeType"] = "text/markdown"; |
|
content["text"] = m_tools.docs().guide(); |
|
} |
|
else if (uri == "sdrangel://packets") |
|
{ |
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.dataFeed().getPackets(QString(), QString(), 100, 0)).toJson(QJsonDocument::Compact)); |
|
} |
|
else if (uri == "sdrangel://map/items") |
|
{ |
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.dataFeed().getMapItems(QString(), QString(), 500, false)).toJson(QJsonDocument::Compact)); |
|
} |
|
else if (uri == "sdrangel://docs") |
|
{ |
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.docs().index()).toJson(QJsonDocument::Compact)); |
|
} |
|
else if (uri.startsWith("sdrangel://docs/")) |
|
{ |
|
QString rest = uri.mid(QString("sdrangel://docs/").size()); |
|
QString kind = rest.section('/', 0, 0); |
|
QString id = rest.section('/', 1); |
|
const MCPDocs::Doc *doc = m_tools.docs().find(id, kind); |
|
|
|
if (!doc) { |
|
throw MCPError(ResourceNotFound, QString("Resource not found: %1. Read sdrangel://docs for the available documentation").arg(uri)); |
|
} |
|
|
|
content["mimeType"] = "text/markdown"; |
|
content["text"] = m_tools.docs().text(*doc); |
|
} |
|
else if (uri.startsWith("sdrangel://deviceset/")) |
|
{ |
|
bool ok; |
|
int index = uri.mid(QString("sdrangel://deviceset/").size()).toInt(&ok); |
|
|
|
if (!ok) { |
|
throw MCPError(InvalidParams, QString("Invalid device set index in %1").arg(uri)); |
|
} |
|
|
|
content["mimeType"] = "application/json"; |
|
content["text"] = QString(QJsonDocument(m_tools.getDeviceSet(index)).toJson(QJsonDocument::Compact)); |
|
} |
|
else |
|
{ |
|
throw MCPError(ResourceNotFound, QString("Resource not found: %1").arg(uri)); |
|
} |
|
|
|
QJsonArray contents; |
|
contents.append(content); |
|
QJsonObject result; |
|
result["contents"] = contents; |
|
return result; |
|
} |
|
|
|
QJsonObject MCPProtocol::promptMessage(const QString& text) |
|
{ |
|
QJsonObject message; |
|
message["role"] = "user"; |
|
message["content"] = textContent(text); |
|
return message; |
|
} |
|
|
|
QJsonValue MCPProtocol::promptsList(const QJsonObject& params) |
|
{ |
|
(void) params; |
|
QJsonArray prompts; |
|
|
|
{ |
|
QJsonObject arg1; |
|
arg1["name"] = "signal"; |
|
arg1["description"] = "What to receive, e.g. ADS-B, AIS, APRS, broadcast FM, an airband frequency in MHz"; |
|
arg1["required"] = true; |
|
QJsonObject arg2; |
|
arg2["name"] = "device"; |
|
arg2["description"] = "Which SDR to use (hardware type or serial). Optional: the first available receiver is used otherwise"; |
|
arg2["required"] = false; |
|
QJsonObject prompt; |
|
prompt["name"] = "setup_receiver"; |
|
prompt["title"] = "Set up a receiver"; |
|
prompt["description"] = "Configure an SDR device and demodulator to receive a given signal or protocol"; |
|
prompt["arguments"] = QJsonArray({arg1, arg2}); |
|
prompts.append(prompt); |
|
} |
|
{ |
|
QJsonObject arg1; |
|
arg1["name"] = "frequency"; |
|
arg1["description"] = "Centre frequency to record, e.g. 126 MHz"; |
|
arg1["required"] = true; |
|
QJsonObject arg2; |
|
arg2["name"] = "duration"; |
|
arg2["description"] = "How long to record for, e.g. 30 seconds"; |
|
arg2["required"] = false; |
|
QJsonObject arg3; |
|
arg3["name"] = "file"; |
|
arg3["description"] = "Output file path"; |
|
arg3["required"] = false; |
|
QJsonObject prompt; |
|
prompt["name"] = "record_iq"; |
|
prompt["title"] = "Record IQ data"; |
|
prompt["description"] = "Record baseband IQ samples from an SDR to a file"; |
|
prompt["arguments"] = QJsonArray({arg1, arg2, arg3}); |
|
prompts.append(prompt); |
|
} |
|
{ |
|
QJsonObject prompt; |
|
prompt["name"] = "explain_configuration"; |
|
prompt["title"] = "Explain the current configuration"; |
|
prompt["description"] = "Describe what SDRangel is currently set up to do"; |
|
prompt["arguments"] = QJsonArray(); |
|
prompts.append(prompt); |
|
} |
|
|
|
QJsonObject result; |
|
result["prompts"] = prompts; |
|
return result; |
|
} |
|
|
|
QJsonValue MCPProtocol::promptsGet(const QJsonObject& params) |
|
{ |
|
QString name = params["name"].toString(); |
|
QJsonObject args = params["arguments"].toObject(); |
|
QJsonObject result; |
|
QJsonArray messages; |
|
|
|
if (name == "setup_receiver") |
|
{ |
|
QString signal = args["signal"].toString(); |
|
QString device = args["device"].toString(); |
|
result["description"] = QString("Set up SDRangel to receive %1").arg(signal); |
|
messages.append(promptMessage(QString( |
|
"Set up SDRangel to receive: %1.%2\n\n" |
|
"1. If you do not already know the frequency and which demodulator this signal needs, call get_receiving_guide.\n" |
|
"2. Call listen with that frequency and mode%3. It picks a device, sets a sample rate that suits the mode, adds the " |
|
"demodulator, starts everything and reports the run state and signal level, so one call replaces the whole " |
|
"device set, settings and channel sequence. Modes are bfm, wfm, nfm, am, ssb, usb, lsb, dab, adsb, ais and dsd, " |
|
"or any channel type id from list_channel_types.\n" |
|
"3. Read what listen returned. If it reports a note, act on it. Adjust with set_channel_settings if the signal needs " |
|
"it (squelch, volume, rfBandwidth) and use get_channel_report to confirm.\n" |
|
"4. Summarise what is now running, including anything that did not work.") |
|
.arg(signal) |
|
.arg(device.isEmpty() ? "" : QString(" Use this device: %1.").arg(device)) |
|
.arg(device.isEmpty() ? "" : QString(" and device \"%1\"").arg(device)))); |
|
} |
|
else if (name == "record_iq") |
|
{ |
|
QString frequency = args["frequency"].toString(); |
|
QString duration = args["duration"].toString(); |
|
QString file = args["file"].toString(); |
|
result["description"] = QString("Record IQ data at %1").arg(frequency); |
|
messages.append(promptMessage(QString( |
|
"Record baseband IQ data from an SDR centred on %1%2%3.\n\n" |
|
"1. Call get_status. If a receiver is already running on that frequency, record from it. Otherwise get one running: " |
|
"listen is the quickest way and confirms a signal is there, or use add_deviceset, set_device_settings and " |
|
"start_device if you want no demodulator.\n" |
|
"2. Call record_iq with the device set, duration and file name for a short capture, or start_iq_recording and " |
|
"stop_iq_recording for a longer one. It adds and removes its own File Sink channel; get_server_status shows the " |
|
"directory the files go to.\n" |
|
"3. Report the files written with their size and duration. Warn the user if the capture will be large: the file grows " |
|
"by roughly four bytes per sample, so a 2 MS/s capture uses about 8 MB per second.") |
|
.arg(frequency) |
|
.arg(duration.isEmpty() ? "" : QString(" for %1").arg(duration)) |
|
.arg(file.isEmpty() ? "" : QString(" to the file %1").arg(file)))); |
|
} |
|
else if (name == "explain_configuration") |
|
{ |
|
result["description"] = "Explain the current SDRangel configuration"; |
|
messages.append(promptMessage( |
|
"Call get_status: it returns one line per device set and feature, with the device, its frequency, its run state and " |
|
"the channels on it. That is usually enough. Only call get_device_settings, get_channel_settings or get_channel_report " |
|
"for a device set the user asks about in more detail, since those return every key and are far larger.\n\n" |
|
"Then explain in plain language what SDRangel is currently configured to do: which SDRs are in use, what frequencies they " |
|
"are tuned to, which demodulators are running and what they are decoding, and whether the devices are running or stopped.")); |
|
} |
|
else |
|
{ |
|
throw MCPError(InvalidParams, QString("Prompt not found: %1").arg(name)); |
|
} |
|
|
|
result["messages"] = messages; |
|
return result; |
|
}
|
|
|