VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2025-03-21 19:58:39 -04:00
Code Issues Projects Releases Wiki Activity

CW keyer: standardize settings processing

Browse Source
This commit is contained in:
f4exb 2019-07-30 01:31:46 +02:00
parent 57efa91a5b
commit 1f30f527f5
19 changed files with 197 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
plugins/channeltx/modam/ammod.cpp
View File

@ -75,11 +75,8 @@ AMMod::AMMod(DeviceAPI *deviceAPI) :
DSPEngine::instance()->getAudioDeviceManager()->addAudioSource(&m_audioFifo, getInputMessageQueue());
m_audioSampleRate = DSPEngine::instance()->getAudioDeviceManager()->getInputSampleRate();
m_toneNco.setFreq(1000.0, m_audioSampleRate);
// CW keyer
m_cwKeyer.setSampleRate(m_audioSampleRate);
m_cwKeyer.setWPM(13);
m_cwKeyer.setMode(CWKeyerSettings::CWNone);
m_cwKeyer.setSampleRate(m_audioSampleRate);
m_cwKeyer.reset();
applyChannelSettings(m_basebandSampleRate, m_outputSampleRate, m_inputFrequencyOffset, true);
applySettings(m_settings, true);
@ -668,16 +665,13 @@ int AMMod::webapiSettingsPutPatch(
cwKeyerSettings.m_wpm = apiCwKeyerSettings->getWpm();
}
m_cwKeyer.setLoop(cwKeyerSettings.m_loop);
m_cwKeyer.setMode(cwKeyerSettings.m_mode);
m_cwKeyer.setSampleRate(cwKeyerSettings.m_sampleRate);
m_cwKeyer.setText(cwKeyerSettings.m_text);
m_cwKeyer.setWPM(cwKeyerSettings.m_wpm);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_cwKeyer.getInputMessageQueue()->push(msgCwKeyer);
if (m_guiMessageQueue) // forward to GUI if any
{
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyer);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyerToGUI = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyerToGUI);
}
}

6
plugins/channeltx/modam/ammodgui.cpp
View File

@ -119,7 +119,8 @@ bool AMModGUI::handleMessage(const Message& message)
else if (CWKeyer::MsgConfigureCWKeyer::match(message))
{
const CWKeyer::MsgConfigureCWKeyer& cfg = (CWKeyer::MsgConfigureCWKeyer&) message;
ui->cwKeyerGUI->displaySettings(cfg.getSettings());
ui->cwKeyerGUI->setSettings(cfg.getSettings());
ui->cwKeyerGUI->displaySettings();
return true;
}
else
@ -361,7 +362,7 @@ AMModGUI::AMModGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSampl
ui->morseKeyer->setChecked(false);
ui->mic->setChecked(false);
ui->cwKeyerGUI->setBuddies(m_amMod->getInputMessageQueue(), m_amMod->getCWKeyer());
ui->cwKeyerGUI->setCWKeyer(m_amMod->getCWKeyer());
connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleSourceMessages()));
connect(m_amMod, SIGNAL(levelChanged(qreal, qreal, int)), ui->volumeMeter, SLOT(levelChanged(qreal, qreal, int)));
@ -384,7 +385,6 @@ void AMModGUI::blockApplySettings(bool block)
void AMModGUI::applySettings(bool force)
{
(void) force;
if (m_doApplySettings)
{
setTitleColor(m_channelMarker.getColor());

2
plugins/channeltx/modam/ammodplugin.cpp
View File

@ -26,7 +26,7 @@
const PluginDescriptor AMModPlugin::m_pluginDescriptor = {
QString("AM Modulator"),
QString("4.5.2"),
QString("4.11.5"),
QString("(c) Edouard Griffiths, F4EXB"),
QString("https://github.com/f4exb/sdrangel"),
true,

18
plugins/channeltx/modfreedv/freedvmod.cpp
View File

@ -104,11 +104,8 @@ FreeDVMod::FreeDVMod(DeviceAPI *deviceAPI) :
m_magsq = 0.0;
m_toneNco.setFreq(1000.0, m_inputSampleRate);
// CW keyer
m_cwKeyer.setSampleRate(m_inputSampleRate);
m_cwKeyer.setWPM(13);
m_cwKeyer.setMode(CWKeyerSettings::CWNone);
m_cwKeyer.setSampleRate(m_inputSampleRate);
m_cwKeyer.reset();
m_channelizer = new UpChannelizer(this);
m_threadedChannelizer = new ThreadedBasebandSampleSource(m_channelizer, this);
@ -933,16 +930,13 @@ int FreeDVMod::webapiSettingsPutPatch(
cwKeyerSettings.m_wpm = apiCwKeyerSettings->getWpm();
}
m_cwKeyer.setLoop(cwKeyerSettings.m_loop);
m_cwKeyer.setMode(cwKeyerSettings.m_mode);
//m_cwKeyer.setSampleRate(cwKeyerSettings.m_sampleRate);
m_cwKeyer.setText(cwKeyerSettings.m_text);
m_cwKeyer.setWPM(cwKeyerSettings.m_wpm);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_cwKeyer.getInputMessageQueue()->push(msgCwKeyer);
if (m_guiMessageQueue) // forward to GUI if any
{
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyer);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyerToGUI = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyerToGUI);
}
}

5
plugins/channeltx/modfreedv/freedvmodgui.cpp
View File

@ -130,7 +130,8 @@ bool FreeDVModGUI::handleMessage(const Message& message)
else if (CWKeyer::MsgConfigureCWKeyer::match(message))
{
const CWKeyer::MsgConfigureCWKeyer& cfg = (CWKeyer::MsgConfigureCWKeyer&) message;
ui->cwKeyerGUI->displaySettings(cfg.getSettings());
ui->cwKeyerGUI->setSettings(cfg.getSettings());
ui->cwKeyerGUI->displaySettings();
return true;
}
else
@ -384,7 +385,7 @@ FreeDVModGUI::FreeDVModGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, Baseb
connect(&m_channelMarker, SIGNAL(changedByCursor()), this, SLOT(channelMarkerChangedByCursor()));
ui->cwKeyerGUI->setBuddies(m_freeDVMod->getInputMessageQueue(), m_freeDVMod->getCWKeyer());
ui->cwKeyerGUI->setCWKeyer(m_freeDVMod->getCWKeyer());
ui->spectrumGUI->setBuddies(m_spectrumVis->getInputMessageQueue(), m_spectrumVis, ui->glSpectrum);
m_settings.setChannelMarker(&m_channelMarker);

2
plugins/channeltx/modfreedv/freedvmodplugin.cpp
View File

@ -26,7 +26,7 @@
const PluginDescriptor FreeDVModPlugin::m_pluginDescriptor = {
QString("FreeDV Modulator"),
QString("4.5.5"),
QString("4.11.5"),
QString("(c) Edouard Griffiths, F4EXB"),
QString("https://github.com/f4exb/sdrangel"),
true,

16
plugins/channeltx/modnfm/nfmmod.cpp
View File

@ -81,11 +81,8 @@ NFMMod::NFMMod(DeviceAPI *deviceAPI) :
m_lowpass.create(301, m_audioSampleRate, 250.0);
m_toneNco.setFreq(1000.0, m_audioSampleRate);
m_ctcssNco.setFreq(88.5, m_audioSampleRate);
// CW keyer
m_cwKeyer.setSampleRate(m_audioSampleRate);
m_cwKeyer.setWPM(13);
m_cwKeyer.setMode(CWKeyerSettings::CWNone);
m_cwKeyer.reset();
applyChannelSettings(m_basebandSampleRate, m_outputSampleRate, m_inputFrequencyOffset, true);
applySettings(m_settings, true);
@ -724,16 +721,13 @@ int NFMMod::webapiSettingsPutPatch(
cwKeyerSettings.m_wpm = apiCwKeyerSettings->getWpm();
}
m_cwKeyer.setLoop(cwKeyerSettings.m_loop);
m_cwKeyer.setMode(cwKeyerSettings.m_mode);
m_cwKeyer.setSampleRate(cwKeyerSettings.m_sampleRate);
m_cwKeyer.setText(cwKeyerSettings.m_text);
m_cwKeyer.setWPM(cwKeyerSettings.m_wpm);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_cwKeyer.getInputMessageQueue()->push(msgCwKeyer);
if (m_guiMessageQueue) // forward to GUI if any
{
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyer);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyerToGUI = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyerToGUI);
}
}

5
plugins/channeltx/modnfm/nfmmodgui.cpp
View File

@ -118,7 +118,8 @@ bool NFMModGUI::handleMessage(const Message& message)
else if (CWKeyer::MsgConfigureCWKeyer::match(message))
{
const CWKeyer::MsgConfigureCWKeyer& cfg = (CWKeyer::MsgConfigureCWKeyer&) message;
ui->cwKeyerGUI->displaySettings(cfg.getSettings());
ui->cwKeyerGUI->setSettings(cfg.getSettings());
ui->cwKeyerGUI->displaySettings();
return true;
}
else
@ -390,7 +391,7 @@ NFMModGUI::NFMModGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSam
ui->ctcss->addItem(QString("%1").arg((double) NFMModSettings::getCTCSSFreq(i), 0, 'f', 1));
}
ui->cwKeyerGUI->setBuddies(m_nfmMod->getInputMessageQueue(), m_nfmMod->getCWKeyer());
ui->cwKeyerGUI->setCWKeyer(m_nfmMod->getCWKeyer());
connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleSourceMessages()));
connect(m_nfmMod, SIGNAL(levelChanged(qreal, qreal, int)), ui->volumeMeter, SLOT(levelChanged(qreal, qreal, int)));

2
plugins/channeltx/modnfm/nfmmodplugin.cpp
View File

@ -26,7 +26,7 @@
const PluginDescriptor NFMModPlugin::m_pluginDescriptor = {
QString("NFM Modulator"),
QString("4.5.2"),
QString("4.11.5"),
QString("(c) Edouard Griffiths, F4EXB"),
QString("https://github.com/f4exb/sdrangel"),
true,

17
plugins/channeltx/modssb/ssbmod.cpp
View File

@ -100,12 +100,8 @@ SSBMod::SSBMod(DeviceAPI *deviceAPI) :
m_magsq = 0.0;
m_toneNco.setFreq(1000.0, m_audioSampleRate);
// CW keyer
m_cwKeyer.setSampleRate(48000);
m_cwKeyer.setWPM(13);
m_cwKeyer.setMode(CWKeyerSettings::CWNone);
m_cwKeyer.reset();
m_audioCompressor.initSimple(
m_audioSampleRate,
@ -1021,16 +1017,13 @@ int SSBMod::webapiSettingsPutPatch(
cwKeyerSettings.m_wpm = apiCwKeyerSettings->getWpm();
}
m_cwKeyer.setLoop(cwKeyerSettings.m_loop);
m_cwKeyer.setMode(cwKeyerSettings.m_mode);
m_cwKeyer.setSampleRate(cwKeyerSettings.m_sampleRate);
m_cwKeyer.setText(cwKeyerSettings.m_text);
m_cwKeyer.setWPM(cwKeyerSettings.m_wpm);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_cwKeyer.getInputMessageQueue()->push(msgCwKeyer);
if (m_guiMessageQueue) // forward to GUI if any
{
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyer);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyerToGUI = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyerToGUI);
}
}

5
plugins/channeltx/modssb/ssbmodgui.cpp
View File

@ -136,7 +136,8 @@ bool SSBModGUI::handleMessage(const Message& message)
else if (CWKeyer::MsgConfigureCWKeyer::match(message))
{
const CWKeyer::MsgConfigureCWKeyer& cfg = (CWKeyer::MsgConfigureCWKeyer&) message;
ui->cwKeyerGUI->displaySettings(cfg.getSettings());
ui->cwKeyerGUI->setSettings(cfg.getSettings());
ui->cwKeyerGUI->displaySettings();
return true;
}
else
@ -430,7 +431,7 @@ SSBModGUI::SSBModGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSam
connect(&m_channelMarker, SIGNAL(changedByCursor()), this, SLOT(channelMarkerChangedByCursor()));
ui->cwKeyerGUI->setBuddies(m_ssbMod->getInputMessageQueue(), m_ssbMod->getCWKeyer());
ui->cwKeyerGUI->setCWKeyer(m_ssbMod->getCWKeyer());
ui->spectrumGUI->setBuddies(m_spectrumVis->getInputMessageQueue(), m_spectrumVis, ui->glSpectrum);
m_settings.setChannelMarker(&m_channelMarker);

2
plugins/channeltx/modssb/ssbmodplugin.cpp
View File

@ -26,7 +26,7 @@
const PluginDescriptor SSBModPlugin::m_pluginDescriptor = {
QString("SSB Modulator"),
QString("4.11.1"),
QString("4.11.5"),
QString("(c) Edouard Griffiths, F4EXB"),
QString("https://github.com/f4exb/sdrangel"),
true,

15
plugins/channeltx/modwfm/wfmmod.cpp
View File

@ -85,11 +85,7 @@ WFMMod::WFMMod(DeviceAPI *deviceAPI) :
m_audioSampleRate = DSPEngine::instance()->getAudioDeviceManager()->getInputSampleRate();
m_toneNcoRF.setFreq(1000.0, m_outputSampleRate);
// CW keyer
m_cwKeyer.setSampleRate(m_outputSampleRate);
m_cwKeyer.setWPM(13);
m_cwKeyer.setMode(CWKeyerSettings::CWNone);
m_cwKeyer.reset();
applyChannelSettings(m_basebandSampleRate, m_outputSampleRate, m_inputFrequencyOffset, true);
@ -698,16 +694,13 @@ int WFMMod::webapiSettingsPutPatch(
cwKeyerSettings.m_wpm = apiCwKeyerSettings->getWpm();
}
m_cwKeyer.setLoop(cwKeyerSettings.m_loop);
m_cwKeyer.setMode(cwKeyerSettings.m_mode);
m_cwKeyer.setSampleRate(cwKeyerSettings.m_sampleRate);
m_cwKeyer.setText(cwKeyerSettings.m_text);
m_cwKeyer.setWPM(cwKeyerSettings.m_wpm);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_cwKeyer.getInputMessageQueue()->push(msgCwKeyer);
if (m_guiMessageQueue) // forward to GUI if any
{
CWKeyer::MsgConfigureCWKeyer *msgCwKeyer = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyer);
CWKeyer::MsgConfigureCWKeyer *msgCwKeyerToGUI = CWKeyer::MsgConfigureCWKeyer::create(cwKeyerSettings, force);
m_guiMessageQueue->push(msgCwKeyerToGUI);
}
}

5
plugins/channeltx/modwfm/wfmmodgui.cpp
View File

@ -119,7 +119,8 @@ bool WFMModGUI::handleMessage(const Message& message)
else if (CWKeyer::MsgConfigureCWKeyer::match(message))
{
const CWKeyer::MsgConfigureCWKeyer& cfg = (CWKeyer::MsgConfigureCWKeyer&) message;
ui->cwKeyerGUI->displaySettings(cfg.getSettings());
ui->cwKeyerGUI->setSettings(cfg.getSettings());
ui->cwKeyerGUI->displaySettings();
return true;
}
else
@ -375,7 +376,7 @@ WFMModGUI::WFMModGUI(PluginAPI* pluginAPI, DeviceUISet *deviceUISet, BasebandSam
ui->tone->setChecked(false);
ui->mic->setChecked(false);
ui->cwKeyerGUI->setBuddies(m_wfmMod->getInputMessageQueue(), m_wfmMod->getCWKeyer());
ui->cwKeyerGUI->setCWKeyer(m_wfmMod->getCWKeyer());
m_settings.setChannelMarker(&m_channelMarker);
m_settings.setCWKeyerGUI(ui->cwKeyerGUI);

2
plugins/channeltx/modwfm/wfmmodplugin.cpp
View File

@ -26,7 +26,7 @@
const PluginDescriptor WFMModPlugin::m_pluginDescriptor = {
QString("WFM Modulator"),
QString("4.5.2"),
QString("4.11.5"),
QString("(c) Edouard Griffiths, F4EXB"),
QString("https://github.com/f4exb/sdrangel"),
true,

124
sdrbase/dsp/cwkeyer.cpp
View File

@ -175,7 +175,8 @@ CWKeyer::CWKeyer() :
m_keyIambicState(KeySilent),
m_textState(TextStart)
{
setWPM(13);
connect(&m_inputMessageQueue, SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
applySettings(m_settings, true);
}
CWKeyer::~CWKeyer()
@ -184,55 +185,10 @@ CWKeyer::~CWKeyer()
void CWKeyer::setSampleRate(int sampleRate)
{
m_mutex.lock();
m_settings.m_sampleRate = sampleRate;
m_mutex.unlock();
setWPM(m_settings.m_wpm);
}
void CWKeyer::setWPM(int wpm)
{
if ((wpm > 0) && (wpm < 27))
{
QMutexLocker mutexLocker(&m_mutex);
m_dotLength = (int) (0.24f * m_settings.m_sampleRate * (5.0f / wpm));
m_settings.m_wpm = wpm;
m_cwSmoother.setNbFadeSamples(m_dotLength/5); // 20% the dot time
}
}
void CWKeyer::setText(const QString& text)
{
QMutexLocker mutexLocker(&m_mutex);
m_settings.m_text = text;
m_textState = TextStart;
}
void CWKeyer::setMode(CWKeyerSettings::CWMode mode)
{
if (mode != m_settings.m_mode)
{
QMutexLocker mutexLocker(&m_mutex);
if (mode == CWKeyerSettings::CWText)
{
m_textState = TextStart;
}
else if (mode == CWKeyerSettings::CWDots)
{
m_dot = true;
m_dash = false;
m_keyIambicState = KeySilent;
}
else if (mode == CWKeyerSettings::CWDashes)
{
m_dot = false;
m_dash = true;
m_keyIambicState = KeySilent;
}
m_settings.m_mode = mode;
}
CWKeyerSettings settings = m_settings;
settings.m_sampleRate = sampleRate;
MsgConfigureCWKeyer *msg = MsgConfigureCWKeyer::create(settings, false);
m_inputMessageQueue.push(msg);
}
int CWKeyer::getSample()
@ -533,3 +489,71 @@ bool CWSmoother::getFadeSample(bool on, float& sample)
}
}
}
bool CWKeyer::handleMessage(const Message& cmd)
{
if (MsgConfigureCWKeyer::match(cmd))
{
MsgConfigureCWKeyer& cfg = (MsgConfigureCWKeyer&) cmd;
qDebug() << "CWKeyer::handleMessage: MsgConfigureCWKeyer";
applySettings(cfg.getSettings(), cfg.getForce());
return true;
}
return true;
}
void CWKeyer::handleInputMessages()
{
Message* message;
while ((message = m_inputMessageQueue.pop()) != 0)
{
if (handleMessage(*message)) {
delete message;
}
}
}
void CWKeyer::applySettings(const CWKeyerSettings& settings, bool force)
{
if ((m_settings.m_wpm != settings.m_wpm)
|| (m_settings.m_sampleRate != settings.m_sampleRate) || force)
{
QMutexLocker mutexLocker(&m_mutex);
m_dotLength = (int) (0.24f * settings.m_sampleRate * (5.0f / settings.m_wpm));
m_cwSmoother.setNbFadeSamples(m_dotLength/5); // 20% the dot time
}
if ((m_settings.m_mode != settings.m_mode) || force)
{
QMutexLocker mutexLocker(&m_mutex);
if (settings.m_mode == CWKeyerSettings::CWText)
{
m_textState = TextStart;
}
else if (settings.m_mode == CWKeyerSettings::CWDots)
{
m_dot = true;
m_dash = false;
m_keyIambicState = KeySilent;
}
else if (settings.m_mode == CWKeyerSettings::CWDashes)
{
m_dot = false;
m_dash = true;
m_keyIambicState = KeySilent;
}
}
if ((m_settings.m_text != settings.m_text) || force)
{
QMutexLocker mutexLocker(&m_mutex);
m_textState = TextStart;
}
m_settings = settings;
}

24
sdrbase/dsp/cwkeyer.h
View File

@ -24,6 +24,7 @@
#include "export.h"
#include "util/message.h"
#include "util/messagequeue.h"
#include "cwkeyersettings.h"
/**
@ -74,14 +75,14 @@ public:
{ }
};
typedef enum
enum CWKeyIambicState
{
KeySilent,
KeyDot,
KeyDash
} CWKeyIambicState;
};
typedef enum
enum CWTextState
{
TextStart,
TextStartChar,
@ -91,7 +92,7 @@ public:
TextWordSpace,
TextEnd,
TextStop
} CWTextState;
};
CWKeyer();
~CWKeyer();
@ -99,17 +100,10 @@ public:
void resetToDefaults();
QByteArray serialize() const;
bool deserialize(const QByteArray& data);
MessageQueue *getInputMessageQueue() { return &m_inputMessageQueue; } //!< Get the queue for asynchronous inbound communication
void setSampleRate(int sampleRate);
void setWPM(int wpm);
void setText(const QString& text);
void setMode(CWKeyerSettings::CWMode mode);
void setLoop(bool loop) { m_settings.m_loop = loop; }
const CWKeyerSettings& getSettings() const { return m_settings; }
void setDotKey(Qt::Key key) { m_settings.m_dotKey = key; }
void setDotKeyModifiers(Qt::KeyboardModifiers keyboardModifiers) { m_settings.m_dotKeyModifiers = keyboardModifiers; }
void setDashKey(Qt::Key key) { m_settings.m_dashKey = key; }
void setDashKeyModifiers(Qt::KeyboardModifiers keyboardModifiers) { m_settings.m_dashKeyModifiers = keyboardModifiers; }
void reset() { m_keyIambicState = KeySilent; }
@ -122,6 +116,7 @@ public:
private:
QMutex m_mutex;
CWKeyerSettings m_settings;
MessageQueue m_inputMessageQueue;
int m_dotLength; //!< dot length in samples
int m_textPointer;
int m_elementPointer;
@ -139,8 +134,13 @@ private:
static const signed char m_asciiToMorse[128][7];
void applySettings(const CWKeyerSettings& settings, bool force = false);
bool handleMessage(const Message& cmd);
void nextStateIambic();
void nextStateText();
private slots:
void handleInputMessages();
};
#endif /* SDRBASE_DSP_CWKEYER_H_ */

189
sdrgui/gui/cwkeyergui.cpp
View File

@ -30,7 +30,6 @@
CWKeyerGUI::CWKeyerGUI(QWidget* parent) :
QWidget(parent),
ui(new Ui::CWKeyerGUI),
m_messageQueue(nullptr),
m_cwKeyer(nullptr),
m_doApplySettings(true),
m_keyScope(NoKeyScope)
@ -48,58 +47,36 @@ CWKeyerGUI::~CWKeyerGUI()
delete ui;
}
void CWKeyerGUI::setBuddies(MessageQueue* messageQueue, CWKeyer* cwKeyer)
void CWKeyerGUI::setCWKeyer(CWKeyer* cwKeyer)
{
m_messageQueue = messageQueue;
m_cwKeyer = cwKeyer;
applySettings();
sendSettings();
displaySettings(m_cwKeyer->getSettings());
setSettings(cwKeyer->getSettings());
displaySettings();
}
void CWKeyerGUI::resetToDefaults()
{
ui->cwTextEdit->setText("");
ui->cwSpeed->setValue(13);
m_settings.resetToDefaults();
displaySettings();
applySettings(true);
}
QByteArray CWKeyerGUI::serialize() const
{
SimpleSerializer s(1);
s.writeString(1, ui->cwTextEdit->text());
s.writeS32(2, ui->cwSpeed->value());
return s.final();
return m_settings.serialize();
}
bool CWKeyerGUI::deserialize(const QByteArray& data)
{
SimpleDeserializer d(data);
if(!d.isValid())
if (m_settings.deserialize(data))
{
resetToDefaults();
return false;
}
if(d.getVersion() == 1)
{
QString aString;
int aValue;
d.readString(1, &aString, "");
ui->cwTextEdit->setText(aString);
d.readS32(2, &aValue, 13);
ui->cwSpeed->setValue(aValue);
applySettings();
sendSettings();
displaySettings();
applySettings(true);
return true;
}
else
{
resetToDefaults();
return false;
}
}
@ -110,27 +87,21 @@ void CWKeyerGUI::on_cwTextClear_clicked(bool checked)
{
(void) checked;
ui->cwTextEdit->clear();
m_cwKeyer->setText("");
m_settings.m_text = "";
applySettings();
}
void CWKeyerGUI::on_cwTextEdit_editingFinished()
{
if (m_doApplySettings)
{
m_cwKeyer->setText(ui->cwTextEdit->text());
sendSettings();
}
m_settings.m_text = ui->cwTextEdit->text();
applySettings();
}
void CWKeyerGUI::on_cwSpeed_valueChanged(int value)
{
ui->cwSpeedText->setText(QString("%1").arg(value));
if (m_doApplySettings)
{
m_cwKeyer->setWPM(value);
sendSettings();
}
m_settings.m_wpm = value;
applySettings();
}
void CWKeyerGUI::on_playDots_toggled(bool checked)
@ -139,12 +110,8 @@ void CWKeyerGUI::on_playDots_toggled(bool checked)
ui->playDashes->setEnabled(!checked);
ui->playText->setEnabled(!checked);
ui->keyboardKeyer->setEnabled(!checked);
if (m_doApplySettings)
{
m_cwKeyer->setMode(checked ? CWKeyerSettings::CWDots : CWKeyerSettings::CWNone);
sendSettings();
}
m_settings.m_mode = checked ? CWKeyerSettings::CWDots : CWKeyerSettings::CWNone;
applySettings();
}
void CWKeyerGUI::on_playDashes_toggled(bool checked)
@ -153,12 +120,8 @@ void CWKeyerGUI::on_playDashes_toggled(bool checked)
//ui->playDashes->setEnabled(!checked);
ui->playText->setEnabled(!checked);
ui->keyboardKeyer->setEnabled(!checked);
if (m_doApplySettings)
{
m_cwKeyer->setMode(checked ? CWKeyerSettings::CWDashes : CWKeyerSettings::CWNone);
sendSettings();
}
m_settings.m_mode = checked ? CWKeyerSettings::CWDashes : CWKeyerSettings::CWNone;
applySettings();
}
void CWKeyerGUI::on_playText_toggled(bool checked)
@ -168,26 +131,20 @@ void CWKeyerGUI::on_playText_toggled(bool checked)
//ui->playText->setEnabled(!checked);
ui->keyboardKeyer->setEnabled(!checked);
if (m_doApplySettings)
{
m_cwKeyer->setMode(checked ? CWKeyerSettings::CWText : CWKeyerSettings::CWNone);
sendSettings();
}
if (checked) {
ui->playStop->setChecked(true);
} else {
ui->playStop->setChecked(false);
}
m_settings.m_mode = checked ? CWKeyerSettings::CWText : CWKeyerSettings::CWNone;
applySettings();
}
void CWKeyerGUI::on_playLoopCW_toggled(bool checked)
{
if (m_doApplySettings)
{
m_cwKeyer->setLoop(checked);
sendSettings();
}
m_settings.m_loop = checked;
applySettings();
}
void CWKeyerGUI::on_playStop_toggled(bool checked)
@ -258,36 +215,25 @@ void CWKeyerGUI::on_keyDashCapture_toggled(bool checked)
void CWKeyerGUI::commandKeyPressed(Qt::Key key, Qt::KeyboardModifiers keyModifiers, bool release)
{
(void) release;
// qDebug("CWKeyerGUI::commandKeyPressed: key: %x", m_key);
// qDebug("CWKeyerGUI::commandKeyPressed: has modifiers: %x", QFlags<Qt::KeyboardModifier>::Int(keyModifiers));
// qDebug("CWKeyerGUI::commandKeyPressed: key scope: %d", (int) m_keyScope);
// qDebug("CWKeyerGUI::commandKeyPressed: key: %x", key);
// qDebug("CWKeyerGUI::commandKeyPressed: has modifiers: %x", QFlags<Qt::KeyboardModifier>::Int(keyModifiers));
if (m_keyScope == DotKeyScope)
{
m_dotKey = key;
m_dotKeyModifiers = keyModifiers;
setKeyLabel(ui->keyDotLabel, key, keyModifiers);
ui->keyDotCapture->setChecked(false);
if (m_doApplySettings)
{
m_cwKeyer->setDotKey(key);
m_cwKeyer->setDotKeyModifiers(keyModifiers);
sendSettings();
}
m_settings.m_dotKey = key;
m_settings.m_dotKeyModifiers = keyModifiers;
applySettings();
}
else if (m_keyScope == DashKeyScope)
{
m_dashKey = key;
m_dashKeyModifiers = keyModifiers;
setKeyLabel(ui->keyDashLabel, key, keyModifiers);
ui->keyDashCapture->setChecked(false);
if (m_doApplySettings)
{
m_cwKeyer->setDashKey(key);
m_cwKeyer->setDashKeyModifiers(keyModifiers);
sendSettings();
}
m_settings.m_dashKey = key;
m_settings.m_dashKeyModifiers = keyModifiers;
applySettings();
}
m_commandKeyReceiver->setRelease(true);
@ -299,12 +245,8 @@ void CWKeyerGUI::on_keyboardKeyer_toggled(bool checked)
ui->playDots->setEnabled(!checked); // block or release other source inputs
ui->playDashes->setEnabled(!checked);
ui->playText->setEnabled(!checked);
if (m_doApplySettings)
{
m_cwKeyer->setMode(checked ? CWKeyerSettings::CWKeyboard : CWKeyerSettings::CWNone);
sendSettings();
}
m_settings.m_mode = checked ? CWKeyerSettings::CWKeyboard : CWKeyerSettings::CWNone;
applySettings();
if (checked) {
MainWindow::getInstance()->commandKeysConnect(this, SLOT(keyboardKeyPressed(Qt::Key, Qt::KeyboardModifiers, bool)));
@ -329,43 +271,39 @@ void CWKeyerGUI::keyboardKeyPressed(Qt::Key key, Qt::KeyboardModifiers keyModifi
// === End SLOTS ==============================================================
void CWKeyerGUI::applySettings()
void CWKeyerGUI::applySettings(bool force)
{
int value;
m_cwKeyer->setText(ui->cwTextEdit->text());
value = ui->cwSpeed->value();
ui->cwSpeedText->setText(QString("%1").arg(value));
m_cwKeyer->setWPM(value);
m_cwKeyer->setDotKey(m_dotKey);
m_cwKeyer->setDotKeyModifiers(m_dotKeyModifiers);
m_cwKeyer->setDashKey(m_dashKey);
m_cwKeyer->setDashKeyModifiers(m_dashKeyModifiers);
if (m_doApplySettings && m_cwKeyer)
{
CWKeyer::MsgConfigureCWKeyer* message = CWKeyer::MsgConfigureCWKeyer::create(m_settings, force);
m_cwKeyer->getInputMessageQueue()->push(message);
}
}
void CWKeyerGUI::displaySettings(const CWKeyerSettings& settings)
void CWKeyerGUI::displaySettings()
{
blockApplySettings(true);
ui->playLoopCW->setChecked(settings.m_loop);
ui->playLoopCW->setChecked(m_settings.m_loop);
ui->playDots->setEnabled((settings.m_mode == CWKeyerSettings::CWDots) || (settings.m_mode == CWKeyerSettings::CWNone));
ui->playDots->setChecked(settings.m_mode == CWKeyerSettings::CWDots);
ui->playDots->setEnabled((m_settings.m_mode == CWKeyerSettings::CWDots) || (m_settings.m_mode == CWKeyerSettings::CWNone));
ui->playDots->setChecked(m_settings.m_mode == CWKeyerSettings::CWDots);
ui->playDashes->setEnabled((settings.m_mode == CWKeyerSettings::CWDashes) || (settings.m_mode == CWKeyerSettings::CWNone));
ui->playDashes->setChecked(settings.m_mode == CWKeyerSettings::CWDashes);
ui->playDashes->setEnabled((m_settings.m_mode == CWKeyerSettings::CWDashes) || (m_settings.m_mode == CWKeyerSettings::CWNone));
ui->playDashes->setChecked(m_settings.m_mode == CWKeyerSettings::CWDashes);
ui->playText->setEnabled((settings.m_mode == CWKeyerSettings::CWText) || (settings.m_mode == CWKeyerSettings::CWNone));
ui->playText->setChecked(settings.m_mode == CWKeyerSettings::CWText);
ui->playText->setEnabled((m_settings.m_mode == CWKeyerSettings::CWText) || (m_settings.m_mode == CWKeyerSettings::CWNone));
ui->playText->setChecked(m_settings.m_mode == CWKeyerSettings::CWText);
ui->cwTextEdit->setText(settings.m_text);
ui->cwSpeed->setValue(settings.m_wpm);
ui->cwSpeedText->setText(QString("%1").arg(settings.m_wpm));
ui->keyboardKeyer->setEnabled((m_settings.m_mode == CWKeyerSettings::CWKeyboard) || (m_settings.m_mode == CWKeyerSettings::CWNone));
ui->keyboardKeyer->setChecked(m_settings.m_mode == CWKeyerSettings::CWKeyboard);
setKeyLabel(ui->keyDotLabel, settings.m_dotKey, settings.m_dotKeyModifiers);
setKeyLabel(ui->keyDashLabel, settings.m_dashKey, settings.m_dashKeyModifiers);
ui->cwTextEdit->setText(m_settings.m_text);
ui->cwSpeed->setValue(m_settings.m_wpm);
ui->cwSpeedText->setText(QString("%1").arg(m_settings.m_wpm));
setKeyLabel(ui->keyDotLabel, m_settings.m_dotKey, m_settings.m_dotKeyModifiers);
setKeyLabel(ui->keyDashLabel, m_settings.m_dashKey, m_settings.m_dashKeyModifiers);
blockApplySettings(false);
}
@ -392,12 +330,3 @@ void CWKeyerGUI::blockApplySettings(bool block)
{
m_doApplySettings = !block;
}
void CWKeyerGUI::sendSettings()
{
if (m_cwKeyer && m_messageQueue)
{
CWKeyer::MsgConfigureCWKeyer *msg = CWKeyer::MsgConfigureCWKeyer::create(m_cwKeyer->getSettings(), false);
m_messageQueue->push(msg);
}
}

15
sdrgui/gui/cwkeyergui.h
View File

@ -23,6 +23,7 @@
#include "dsp/dsptypes.h"
#include "export.h"
#include "settings/serializable.h"
#include "dsp/cwkeyersettings.h"
namespace Ui {
class CWKeyerGUI;
@ -41,13 +42,14 @@ public:
explicit CWKeyerGUI(QWidget* parent = nullptr);
~CWKeyerGUI();
void setBuddies(MessageQueue* messageQueue, CWKeyer* cwKeyer);
void setCWKeyer(CWKeyer* cwKeyer);
void resetToDefaults();
QByteArray serialize() const;
bool deserialize(const QByteArray& data);
void displaySettings(const CWKeyerSettings& settings);
void setSettings(const CWKeyerSettings& settings) { m_settings = settings; }
void displaySettings();
private:
enum KeyScope
@ -59,18 +61,13 @@ private:
Ui::CWKeyerGUI* ui;
MessageQueue* m_messageQueue;
CWKeyer* m_cwKeyer;
CWKeyerSettings m_settings;
bool m_doApplySettings;
CommandKeyReceiver *m_commandKeyReceiver;
KeyScope m_keyScope;
Qt::Key m_dotKey;
Qt::KeyboardModifiers m_dotKeyModifiers;
Qt::Key m_dashKey;
Qt::KeyboardModifiers m_dashKeyModifiers;
void applySettings();
void sendSettings();
void applySettings(bool force = false);
void blockApplySettings(bool block);
void setKeyLabel(QLabel *label, Qt::Key key, Qt::KeyboardModifiers keyModifiers);