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.
334 lines
10 KiB
334 lines
10 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Dan Chokola, KD2HSG // |
|
// Based on the packet modulator plugin: // |
|
// Copyright (C) 2020-2023 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Copyright (C) 2020-2022 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// // |
|
// 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 <algorithm> |
|
#include <cmath> |
|
|
|
#include <chirpmodem.h> |
|
|
|
#include "dsp/basebandsamplesink.h" |
|
|
|
#include "chirpmodemmodsource.h" |
|
|
|
namespace ChirpModemModGen { |
|
|
|
MESSAGE_CLASS_DEFINITION(MsgGenerated, Message) |
|
|
|
// All the policy checks are libchirpmodem's: a licensed frame without a source |
|
// callsign is refused (EPOLICY), and so is a CW ID faster than 20 WPM. |
|
void generate(Transmission& transmission) |
|
{ |
|
const Job& job = transmission.m_job; |
|
const ChirpModemModSettings& s = job.m_settings; |
|
transmission.m_iq.clear(); |
|
transmission.m_position = 0; |
|
transmission.m_frames = 0; |
|
transmission.m_error.clear(); |
|
|
|
if (job.m_channelSampleRate <= 0) |
|
{ |
|
transmission.m_error = QStringLiteral("No channel sample rate yet: start the device"); |
|
return; |
|
} |
|
|
|
chirpmodem_tx_config tc; |
|
chirpmodem_tx_config_init(&tc); |
|
tc.sf = s.m_spreadFactor; |
|
tc.bw = s.m_bandwidth; |
|
tc.fs = job.m_channelSampleRate; |
|
tc.if_offset = job.m_channelFrequencyOffset; |
|
tc.coherent = s.m_mode; |
|
tc.profile = s.m_profile; |
|
tc.amp = s.m_amplitude; |
|
|
|
int err = CHIRPMODEM_OK; |
|
chirpmodem_tx *tx = chirpmodem_tx_new(&tc, &err); |
|
|
|
if (!tx) |
|
{ |
|
transmission.m_error = QString("Transmitter: %1 (SF %2, BW %3 Hz, fs %4 Hz, IF %5 Hz)") |
|
.arg(chirpmodem_strerror(err)).arg(tc.sf).arg(tc.bw).arg(tc.fs).arg(tc.if_offset); |
|
return; |
|
} |
|
|
|
QByteArray src = job.m_source.toLatin1(); |
|
QByteArray dst = job.m_destination.toLatin1(); |
|
const char *srcp = src.isEmpty() ? nullptr : src.constData(); |
|
const char *dstp = dst.isEmpty() ? nullptr : dst.constData(); |
|
const uint8_t *body = reinterpret_cast<const uint8_t *>(job.m_body.constData()); |
|
|
|
long frameLen = chirpmodem_tx_frame(tx, srcp, dstp, body, job.m_body.size(), 0, nullptr, 0); |
|
|
|
if (frameLen < 0) |
|
{ |
|
transmission.m_error = QString("Frame refused: %1").arg(chirpmodem_strerror((int) frameLen)); |
|
chirpmodem_tx_free(tx); |
|
return; |
|
} |
|
|
|
std::vector<float> frame(2 * frameLen); |
|
chirpmodem_tx_frame(tx, srcp, dstp, body, job.m_body.size(), 0, frame.data(), frameLen); |
|
std::vector<float> cw; |
|
|
|
if (s.m_cwId && srcp) |
|
{ |
|
long cwLen = chirpmodem_tx_cw_id(tx, srcp, s.m_cwWpm, nullptr, 0); |
|
|
|
if (cwLen < 0) |
|
{ |
|
transmission.m_error = QString("CW ID refused: %1").arg(chirpmodem_strerror((int) cwLen)); |
|
chirpmodem_tx_free(tx); |
|
return; |
|
} |
|
|
|
cw.resize(2 * cwLen); |
|
chirpmodem_tx_cw_id(tx, srcp, s.m_cwWpm, cw.data(), cwLen); |
|
} |
|
|
|
chirpmodem_tx_free(tx); |
|
|
|
const size_t gap = 2 * (size_t) std::lround(s.m_gap * job.m_channelSampleRate); |
|
std::vector<float>& iq = transmission.m_iq; |
|
iq.reserve(s.m_repeat * (frame.size() + gap) + cw.size() + gap); |
|
|
|
for (int i = 0; i < s.m_repeat; i++) |
|
{ |
|
if (i > 0) { |
|
iq.insert(iq.end(), gap, 0.0f); |
|
} |
|
|
|
iq.insert(iq.end(), frame.begin(), frame.end()); |
|
} |
|
|
|
if (!cw.empty()) |
|
{ |
|
iq.insert(iq.end(), gap, 0.0f); |
|
iq.insert(iq.end(), cw.begin(), cw.end()); |
|
} |
|
|
|
transmission.m_frames = s.m_repeat; |
|
} |
|
|
|
} // namespace ChirpModemModGen |
|
|
|
using ChirpModemModGen::Job; |
|
using ChirpModemModGen::Transmission; |
|
|
|
ChirpModemModSource::ChirpModemModSource() |
|
{ |
|
} |
|
|
|
ChirpModemModSource::~ChirpModemModSource() |
|
{ |
|
} |
|
|
|
void ChirpModemModSource::applySettings(const QStringList& settingsKeys, const ChirpModemModSettings& settings, bool force) |
|
{ |
|
// Settings apply to the next request. Queued transmissions keep theirs. |
|
if (force) { |
|
m_settings = settings; |
|
} else { |
|
m_settings.applySettings(settingsKeys, settings); |
|
} |
|
} |
|
|
|
std::vector<Job> ChirpModemModSource::applyChannelSettings(int channelSampleRate, int channelFrequencyOffset) |
|
{ |
|
std::vector<Job> again; |
|
|
|
if ((channelSampleRate == m_channelSampleRate) && (channelFrequencyOffset == m_channelFrequencyOffset)) { |
|
return again; |
|
} |
|
|
|
qDebug() << "ChirpModemModSource::applyChannelSettings: rate" << channelSampleRate << "offset" << channelFrequencyOffset; |
|
m_channelSampleRate = channelSampleRate; |
|
m_channelFrequencyOffset = channelFrequencyOffset; |
|
m_levelNbSamples = std::max(100, channelSampleRate / 100); |
|
|
|
if (m_current) |
|
{ |
|
m_current.reset(); |
|
m_lastError = QStringLiteral("Transmission cut off: the channel rate or offset changed"); |
|
sendStatus(QStringLiteral("aborted")); |
|
} |
|
|
|
// Waiting transmissions were made for the old rate: generate them again |
|
for (const auto& transmission : m_queue) |
|
{ |
|
Job job = transmission->m_job; |
|
job.m_channelSampleRate = m_channelSampleRate; |
|
job.m_channelFrequencyOffset = m_channelFrequencyOffset; |
|
job.m_regenerated = true; |
|
again.push_back(job); |
|
} |
|
|
|
m_queue.clear(); |
|
return again; |
|
} |
|
|
|
void ChirpModemModSource::reset() |
|
{ |
|
m_epoch++; |
|
m_queue.clear(); |
|
m_current.reset(); |
|
m_pending = 0; |
|
m_framesSent = 0; |
|
m_transmissions = 0; |
|
m_samplesOnAir = 0; |
|
m_lastDuration = 0; |
|
m_lastError.clear(); |
|
} |
|
|
|
Job ChirpModemModSource::makeJob(const ChirpModemModMessages::TxRequest& request) |
|
{ |
|
Job job; |
|
job.m_settings = m_settings; |
|
job.m_channelSampleRate = m_channelSampleRate; |
|
job.m_channelFrequencyOffset = m_channelFrequencyOffset; |
|
job.m_epoch = m_epoch; |
|
|
|
if (request.m_override) |
|
{ |
|
job.m_source = request.m_source.trimmed().toUpper(); |
|
job.m_destination = request.m_destination.trimmed().toUpper(); |
|
job.m_body = request.m_body; |
|
} |
|
else |
|
{ |
|
job.m_source = m_settings.m_source; |
|
job.m_destination = m_settings.m_destination; |
|
job.m_body = m_settings.m_message.toUtf8(); |
|
} |
|
|
|
return job; |
|
} |
|
|
|
bool ChirpModemModSource::addGenerated(std::shared_ptr<Transmission> transmission) |
|
{ |
|
const Job& job = transmission->m_job; |
|
|
|
if (job.m_epoch != m_epoch) { |
|
return true; // from before a reset: dropped |
|
} |
|
|
|
m_pending = std::max(0, m_pending - 1); |
|
|
|
if ((job.m_channelSampleRate != m_channelSampleRate) || (job.m_channelFrequencyOffset != m_channelFrequencyOffset)) { |
|
return false; // the rate changed while it was being made |
|
} |
|
|
|
if (!transmission->m_error.isEmpty()) |
|
{ |
|
m_lastError = transmission->m_error; |
|
qWarning() << "ChirpModemModSource::addGenerated:" << m_lastError; |
|
sendStatus(QStringLiteral("error")); |
|
return true; |
|
} |
|
|
|
if (!job.m_regenerated) { |
|
m_lastError.clear(); // a new request succeeded |
|
} |
|
|
|
m_lastDuration = transmission->m_iq.size() / 2.0 / job.m_channelSampleRate; |
|
m_queue.push_back(transmission); |
|
sendStatus(QStringLiteral("queued")); |
|
return true; |
|
} |
|
|
|
void ChirpModemModSource::pull(SampleVector::iterator begin, unsigned int nbSamples) |
|
{ |
|
std::for_each(begin, begin + nbSamples, [this](Sample& s) { pullOne(s); }); |
|
|
|
if (m_spectrumSink) { |
|
m_spectrumSink->feed(begin, begin + nbSamples, false); |
|
} |
|
} |
|
|
|
void ChirpModemModSource::pullOne(Sample& sample) |
|
{ |
|
if (!m_current && !m_queue.empty()) |
|
{ |
|
m_current = m_queue.front(); |
|
m_queue.pop_front(); |
|
sendStatus(QStringLiteral("started")); |
|
} |
|
|
|
double magSq = 0; |
|
|
|
if (m_current) |
|
{ |
|
const std::vector<float>& iq = m_current->m_iq; |
|
size_t i = 2 * m_current->m_position; |
|
float re = iq[i]; |
|
float im = iq[i + 1]; |
|
sample.setReal((FixReal) std::lround(re * SDR_TX_SCALEF)); |
|
sample.setImag((FixReal) std::lround(im * SDR_TX_SCALEF)); |
|
magSq = (double) re * re + (double) im * im; |
|
m_samplesOnAir++; |
|
|
|
if (++m_current->m_position >= iq.size() / 2) |
|
{ |
|
m_framesSent += m_current->m_frames; |
|
m_transmissions++; |
|
m_current.reset(); // one free per transmission |
|
|
|
sendStatus(QStringLiteral("sent")); |
|
} |
|
} |
|
else |
|
{ |
|
sample.setReal(0); |
|
sample.setImag(0); |
|
} |
|
|
|
m_levelSum += magSq; |
|
m_levelPeak = std::max(m_levelPeak, magSq); |
|
|
|
if (++m_levelCount >= m_levelNbSamples) |
|
{ |
|
m_rmsLevel = std::sqrt(m_levelSum / m_levelCount); |
|
m_peakLevel = std::sqrt(m_levelPeak); |
|
m_levelSum = 0; |
|
m_levelPeak = 0; |
|
m_levelCount = 0; |
|
} |
|
} |
|
|
|
void ChirpModemModSource::sendStatus(const QString& event) |
|
{ |
|
if (!m_messageQueueToChannel) { |
|
return; |
|
} |
|
|
|
ChirpModemModMessages::Status status; |
|
status.m_event = event; |
|
status.m_error = m_lastError; |
|
status.m_transmitting = m_current != nullptr; |
|
status.m_queueLength = (int) m_queue.size() + m_pending; |
|
status.m_framesSent = m_framesSent; |
|
status.m_transmissions = m_transmissions; |
|
status.m_airtime = m_channelSampleRate > 0 ? (double) m_samplesOnAir / m_channelSampleRate : 0; |
|
status.m_lastDuration = m_lastDuration; |
|
status.m_channelSampleRate = m_channelSampleRate; |
|
status.m_ifOffset = m_channelFrequencyOffset; |
|
m_messageQueueToChannel->push(ChirpModemModMessages::MsgStatus::create(status)); |
|
}
|
|
|