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

///////////////////////////////////////////////////////////////////////////////////
// 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));
}