mirror of
https://github.com/f4exb/sdrangel.git
synced 2024-11-29 19:28:47 -05:00
411 lines
13 KiB
C++
411 lines
13 KiB
C++
///////////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (C) 2020 Edouard Griffiths, F4EXB //
|
|
// //
|
|
// 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 "chirpchatmodsource.h"
|
|
|
|
const int ChirpChatModSource::m_levelNbSamples = 480; // every 10ms
|
|
|
|
ChirpChatModSource::ChirpChatModSource() :
|
|
m_channelSampleRate(48000),
|
|
m_channelFrequencyOffset(0),
|
|
m_phaseIncrements(nullptr),
|
|
m_repeatCount(0),
|
|
m_active(false),
|
|
m_modPhasor(0.0f),
|
|
m_levelCalcCount(0),
|
|
m_peakLevel(0.0f),
|
|
m_levelSum(0.0f)
|
|
{
|
|
m_magsq = 0.0;
|
|
|
|
initSF(m_settings.m_spreadFactor);
|
|
initTest(m_settings.m_spreadFactor, m_settings.m_deBits);
|
|
reset();
|
|
applySettings(m_settings, true);
|
|
applyChannelSettings(m_channelSampleRate, m_channelFrequencyOffset, true);
|
|
}
|
|
|
|
ChirpChatModSource::~ChirpChatModSource()
|
|
{
|
|
delete[] m_phaseIncrements;
|
|
}
|
|
|
|
void ChirpChatModSource::initSF(unsigned int sf)
|
|
{
|
|
m_fftLength = 1 << sf;
|
|
m_state = ChirpChatStateIdle;
|
|
m_quarterSamples = (m_fftLength/4)*ChirpChatModSettings::oversampling;
|
|
|
|
float halfAngle = M_PI/ChirpChatModSettings::oversampling;
|
|
float phase = -halfAngle;
|
|
|
|
if (m_phaseIncrements) {
|
|
delete[] m_phaseIncrements;
|
|
}
|
|
|
|
m_phaseIncrements = new double[2*m_fftLength*ChirpChatModSettings::oversampling];
|
|
phase = -halfAngle;
|
|
|
|
for (unsigned int i = 0; i < m_fftLength*ChirpChatModSettings::oversampling; i++)
|
|
{
|
|
m_phaseIncrements[i] = phase;
|
|
phase += (2*halfAngle) / (m_fftLength*ChirpChatModSettings::oversampling);
|
|
}
|
|
|
|
std::copy(
|
|
m_phaseIncrements,
|
|
m_phaseIncrements+m_fftLength*ChirpChatModSettings::oversampling,
|
|
m_phaseIncrements+m_fftLength*ChirpChatModSettings::oversampling
|
|
);
|
|
}
|
|
|
|
void ChirpChatModSource::initTest(unsigned int sf, unsigned int deBits)
|
|
{
|
|
unsigned int fftLength = 1<<sf;
|
|
unsigned int symbolRange = fftLength/(1<<deBits);
|
|
m_symbols.clear();
|
|
|
|
for (unsigned int seq = 0; seq < 1; seq++)
|
|
{
|
|
for (unsigned int symbol = 0; symbol < symbolRange; symbol += symbolRange/4)
|
|
{
|
|
m_symbols.push_back(symbol);
|
|
m_symbols.push_back(symbol+1);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChirpChatModSource::reset()
|
|
{
|
|
m_chirp = 0;
|
|
m_chirp0 = 0;
|
|
m_sampleCounter = 0;
|
|
m_fftCounter = 0;
|
|
m_chirpCount = 0;
|
|
}
|
|
|
|
void ChirpChatModSource::pull(SampleVector::iterator begin, unsigned int nbSamples)
|
|
{
|
|
std::for_each(
|
|
begin,
|
|
begin + nbSamples,
|
|
[this](Sample& s) {
|
|
pullOne(s);
|
|
}
|
|
);
|
|
}
|
|
|
|
void ChirpChatModSource::pullOne(Sample& sample)
|
|
{
|
|
if (m_settings.m_channelMute)
|
|
{
|
|
sample.m_real = 0.0f;
|
|
sample.m_imag = 0.0f;
|
|
m_magsq = 0.0;
|
|
return;
|
|
}
|
|
|
|
Complex ci;
|
|
|
|
if (m_interpolatorDistance > 1.0f) // decimate
|
|
{
|
|
modulateSample();
|
|
|
|
while (!m_interpolator.decimate(&m_interpolatorDistanceRemain, m_modSample, &ci))
|
|
{
|
|
modulateSample();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_interpolator.interpolate(&m_interpolatorDistanceRemain, m_modSample, &ci))
|
|
{
|
|
modulateSample();
|
|
}
|
|
}
|
|
|
|
m_interpolatorDistanceRemain += m_interpolatorDistance;
|
|
|
|
ci *= m_carrierNco.nextIQ(); // shift to carrier frequency
|
|
|
|
if (!(m_state == ChirpChatStateIdle))
|
|
{
|
|
double magsq = std::norm(ci);
|
|
magsq /= (SDR_TX_SCALED*SDR_TX_SCALED);
|
|
m_movingAverage(magsq);
|
|
m_magsq = m_movingAverage.asDouble();
|
|
}
|
|
|
|
sample.m_real = (FixReal) ci.real();
|
|
sample.m_imag = (FixReal) ci.imag();
|
|
}
|
|
|
|
void ChirpChatModSource::modulateSample()
|
|
{
|
|
if (m_state == ChirpChatStateIdle)
|
|
{
|
|
m_modSample = Complex{0.0, 0.0};
|
|
m_sampleCounter++;
|
|
|
|
if (m_sampleCounter == m_quietSamples*ChirpChatModSettings::oversampling) // done with quiet time
|
|
{
|
|
m_chirp0 = 0;
|
|
m_chirp = m_fftLength*ChirpChatModSettings::oversampling - 1;
|
|
|
|
if (m_symbols.size() != 0) // some payload to transmit
|
|
{
|
|
if (m_settings.m_messageRepeat == 0) // infinite
|
|
{
|
|
m_state = ChirpChatStatePreamble;
|
|
m_active = true;
|
|
}
|
|
else
|
|
{
|
|
if (m_repeatCount != 0)
|
|
{
|
|
m_repeatCount--;
|
|
m_state = ChirpChatStatePreamble;
|
|
m_active = true;
|
|
}
|
|
else
|
|
{
|
|
m_active = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_active = false;
|
|
}
|
|
}
|
|
}
|
|
else if (m_state == ChirpChatStatePreamble)
|
|
{
|
|
m_modPhasor += m_phaseIncrements[m_chirp]; // up chirps
|
|
m_modSample = Complex(std::polar(0.891235351562 * SDR_TX_SCALED, m_modPhasor));
|
|
m_fftCounter++;
|
|
|
|
if (m_fftCounter == m_fftLength*ChirpChatModSettings::oversampling)
|
|
{
|
|
m_chirpCount++;
|
|
m_fftCounter = 0;
|
|
|
|
if (m_chirpCount == m_settings.m_preambleChirps)
|
|
{
|
|
m_chirpCount = 0;
|
|
|
|
if (m_settings.hasSyncWord())
|
|
{
|
|
m_chirp0 = ((m_settings.m_syncWord >> ((1-m_chirpCount)*4)) & 0xf)*8;
|
|
m_chirp = (m_chirp0 + m_fftLength)*ChirpChatModSettings::oversampling - 1;
|
|
m_state = ChirpChatStateSyncWord;
|
|
}
|
|
else
|
|
{
|
|
m_sampleCounter = 0;
|
|
m_chirp0 = 0;
|
|
m_chirp = m_fftLength*ChirpChatModSettings::oversampling - 1;
|
|
m_state = ChirpChatStateSFD;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_state == ChirpChatStateSyncWord)
|
|
{
|
|
m_modPhasor += m_phaseIncrements[m_chirp]; // up chirps
|
|
m_modSample = Complex(std::polar(0.891235351562 * SDR_TX_SCALED, m_modPhasor));
|
|
m_fftCounter++;
|
|
|
|
if (m_fftCounter == m_fftLength*ChirpChatModSettings::oversampling)
|
|
{
|
|
m_chirpCount++;
|
|
m_chirp0 = ((m_settings.m_syncWord >> ((1-m_chirpCount)*4)) & 0xf)*8;
|
|
m_chirp = (m_chirp0 + m_fftLength)*ChirpChatModSettings::oversampling - 1;
|
|
m_fftCounter = 0;
|
|
|
|
if (m_chirpCount == 2)
|
|
{
|
|
m_sampleCounter = 0;
|
|
m_chirpCount = 0;
|
|
m_chirp0 = 0;
|
|
m_chirp = m_fftLength*ChirpChatModSettings::oversampling - 1;
|
|
m_state = ChirpChatStateSFD;
|
|
}
|
|
}
|
|
}
|
|
else if (m_state == ChirpChatStateSFD)
|
|
{
|
|
m_modPhasor -= m_phaseIncrements[m_chirp]; // down chirps
|
|
m_modSample = Complex(std::polar(0.891235351562 * SDR_TX_SCALED, m_modPhasor));
|
|
m_fftCounter++;
|
|
m_sampleCounter++;
|
|
|
|
if (m_fftCounter == m_fftLength*ChirpChatModSettings::oversampling)
|
|
{
|
|
m_chirp0 = 0;
|
|
m_chirp = m_fftLength*ChirpChatModSettings::oversampling - 1;
|
|
m_fftCounter = 0;
|
|
}
|
|
|
|
if (m_sampleCounter == m_quarterSamples)
|
|
{
|
|
m_chirpCount++;
|
|
m_sampleCounter = 0;
|
|
}
|
|
|
|
if (m_chirpCount == m_settings.getNbSFDFourths())
|
|
{
|
|
m_fftCounter = 0;
|
|
m_chirpCount = 0;
|
|
m_chirp0 = encodeSymbol(m_symbols[m_chirpCount]);
|
|
m_chirp = (m_chirp0 + m_fftLength)*ChirpChatModSettings::oversampling - 1;
|
|
m_state = ChirpChatStatePayload;
|
|
}
|
|
}
|
|
else if (m_state == ChirpChatStatePayload)
|
|
{
|
|
m_modPhasor += m_phaseIncrements[m_chirp]; // up chirps
|
|
m_modSample = Complex(std::polar(0.891235351562 * SDR_TX_SCALED, m_modPhasor));
|
|
m_fftCounter++;
|
|
|
|
if (m_fftCounter == m_fftLength*ChirpChatModSettings::oversampling)
|
|
{
|
|
m_chirpCount++;
|
|
|
|
if (m_chirpCount == m_symbols.size())
|
|
{
|
|
reset();
|
|
m_state = ChirpChatStateIdle;
|
|
}
|
|
else
|
|
{
|
|
m_chirp0 = encodeSymbol(m_symbols[m_chirpCount]);
|
|
m_chirp = (m_chirp0 + m_fftLength)*ChirpChatModSettings::oversampling - 1;
|
|
m_fftCounter = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// limit phasor range to ]-pi,pi]
|
|
if (m_modPhasor > M_PI) {
|
|
m_modPhasor -= (2.0f * M_PI);
|
|
}
|
|
|
|
m_chirp++;
|
|
|
|
if (m_chirp >= (m_chirp0 + m_fftLength)*ChirpChatModSettings::oversampling) {
|
|
m_chirp = m_chirp0*ChirpChatModSettings::oversampling;
|
|
}
|
|
}
|
|
|
|
unsigned short ChirpChatModSource::encodeSymbol(unsigned short symbol)
|
|
{
|
|
if (m_settings.m_deBits == 0) {
|
|
return symbol;
|
|
}
|
|
|
|
unsigned int deWidth = 1<<m_settings.m_deBits;
|
|
unsigned int baseSymbol = symbol % (m_fftLength/deWidth); // symbols range control
|
|
return deWidth*baseSymbol;
|
|
// return deWidth*baseSymbol + (deWidth/2) - 1;
|
|
}
|
|
|
|
void ChirpChatModSource::calculateLevel(Real& sample)
|
|
{
|
|
if (m_levelCalcCount < m_levelNbSamples)
|
|
{
|
|
m_peakLevel = std::max(std::fabs(m_peakLevel), sample);
|
|
m_levelSum += sample * sample;
|
|
m_levelCalcCount++;
|
|
}
|
|
else
|
|
{
|
|
m_rmsLevel = sqrt(m_levelSum / m_levelNbSamples);
|
|
m_peakLevelOut = m_peakLevel;
|
|
m_peakLevel = 0.0f;
|
|
m_levelSum = 0.0f;
|
|
m_levelCalcCount = 0;
|
|
}
|
|
}
|
|
|
|
void ChirpChatModSource::applySettings(const ChirpChatModSettings& settings, bool force)
|
|
{
|
|
if ((settings.m_spreadFactor != m_settings.m_spreadFactor)
|
|
|| (settings.m_deBits != m_settings.m_deBits)
|
|
|| (settings.m_preambleChirps != m_settings.m_preambleChirps)|| force)
|
|
{
|
|
initSF(settings.m_spreadFactor);
|
|
initTest(settings.m_spreadFactor, settings.m_deBits);
|
|
reset();
|
|
}
|
|
|
|
if ((settings.m_quietMillis != m_settings.m_quietMillis) || force)
|
|
{
|
|
m_quietSamples = (m_bandwidth*settings.m_quietMillis) / 1000;
|
|
reset();
|
|
}
|
|
|
|
if ((settings.m_messageRepeat != m_settings.m_messageRepeat) || force) {
|
|
m_repeatCount = settings.m_messageRepeat;
|
|
}
|
|
|
|
m_settings = settings;
|
|
}
|
|
|
|
void ChirpChatModSource::applyChannelSettings(int channelSampleRate, int bandwidth, int channelFrequencyOffset, bool force)
|
|
{
|
|
qDebug() << "ChirpChatModSource::applyChannelSettings:"
|
|
<< " channelSampleRate: " << channelSampleRate
|
|
<< " channelFrequencyOffset: " << channelFrequencyOffset
|
|
<< " bandwidth: " << bandwidth
|
|
<< " SR: " << bandwidth * ChirpChatModSettings::oversampling;
|
|
|
|
if ((channelFrequencyOffset != m_channelFrequencyOffset)
|
|
|| (channelSampleRate != m_channelSampleRate) || force)
|
|
{
|
|
m_carrierNco.setFreq(channelFrequencyOffset, channelSampleRate);
|
|
}
|
|
|
|
if ((channelSampleRate != m_channelSampleRate)
|
|
|| (bandwidth != m_bandwidth) || force)
|
|
{
|
|
m_interpolatorDistanceRemain = 0;
|
|
m_interpolatorConsumed = false;
|
|
m_interpolatorDistance = (Real) (bandwidth*ChirpChatModSettings::oversampling) / (Real) channelSampleRate;
|
|
m_interpolator.create(16, bandwidth, bandwidth / 2.2);
|
|
}
|
|
|
|
m_channelSampleRate = channelSampleRate;
|
|
m_channelFrequencyOffset = channelFrequencyOffset;
|
|
m_bandwidth = bandwidth;
|
|
m_quietSamples = (bandwidth*m_settings.m_quietMillis) / 1000;
|
|
m_state = ChirpChatStateIdle;
|
|
reset();
|
|
}
|
|
|
|
void ChirpChatModSource::setSymbols(const std::vector<unsigned short>& symbols)
|
|
{
|
|
m_symbols = symbols;
|
|
qDebug("ChirpChatModSource::setSymbols: m_symbols: %lu", m_symbols.size());
|
|
m_repeatCount = m_settings.m_messageRepeat;
|
|
m_state = ChirpChatStateIdle; // first reset to idle
|
|
reset();
|
|
m_sampleCounter = m_quietSamples*ChirpChatModSettings::oversampling - 1; // start immediately
|
|
}
|