comicsansg/CubicSDR
comicsansg
/
CubicSDR
mirror of https://github.com/cjcliffe/CubicSDR.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #109 from cjcliffe/save_device_prefs 

Save device prefs
This commit is contained in:
Charles J. Cliffe 2015-07-14 20:35:28 -04:00
parent dbc85d4f29 425927fb9e
commit 1d20fd16bb
7 changed files with 208 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
src/AppConfig.cpp
View File

@ -1,36 +1,76 @@
#include "AppConfig.h"
#include "CubicSDR.h"
DeviceConfig::DeviceConfig() : ppm(0), deviceId("") {
DeviceConfig::DeviceConfig() : deviceId("") {
ppm.store(0);
directSampling.store(false);
offset.store(0);
}
DeviceConfig::DeviceConfig(std::string deviceId) : ppm(0) {
DeviceConfig::DeviceConfig(std::string deviceId) : DeviceConfig() {
this->deviceId = deviceId;
}
void DeviceConfig::setPPM(int ppm) {
this->ppm = ppm;
this->ppm.store(ppm);
}
int DeviceConfig::getPPM() {
return ppm;
return ppm.load();
}
void DeviceConfig::setDirectSampling(int mode) {
directSampling.store(mode);
}
int DeviceConfig::getDirectSampling() {
return directSampling.load();
}
void DeviceConfig::setOffset(long long offset) {
this->offset.store(offset);
}
long long DeviceConfig::getOffset() {
return offset.load();
}
void DeviceConfig::setIQSwap(bool iqSwap) {
this->iqSwap.store(iqSwap);
}
bool DeviceConfig::getIQSwap() {
return iqSwap.load();
}
void DeviceConfig::setDeviceId(std::string deviceId) {
busy_lock.lock();
this->deviceId = deviceId;
busy_lock.unlock();
}
std::string DeviceConfig::getDeviceId() {
return deviceId;
std::string tmp;
busy_lock.lock();
tmp = deviceId;
busy_lock.unlock();
return tmp;
}
void DeviceConfig::save(DataNode *node) {
node->newChild("id")->element()->set(deviceId);
DataNode *ppm_node = node->newChild("ppm");
ppm_node->element()->set((int)ppm);
busy_lock.lock();
*node->newChild("id") = deviceId;
*node->newChild("ppm") = (int)ppm;
*node->newChild("iq_swap") = iqSwap;
*node->newChild("direct_sampling") = directSampling;
*node->newChild("offset") = offset;
busy_lock.unlock();
}
void DeviceConfig::load(DataNode *node) {
busy_lock.lock();
if (node->hasAnother("ppm")) {
DataNode *ppm_node = node->getNext("ppm");
int ppmValue = 0;
@ -38,11 +78,48 @@ void DeviceConfig::load(DataNode *node) {
setPPM(ppmValue);
std::cout << "Loaded PPM for device '" << deviceId << "' at " << ppmValue << "ppm" << std::endl;
}
if (node->hasAnother("iq_swap")) {
DataNode *iq_swap_node = node->getNext("iq_swap");
int iqSwapValue = 0;
iq_swap_node->element()->get(iqSwapValue);
setIQSwap(iqSwapValue?true:false);
std::cout << "Loaded I/Q Swap for device '" << deviceId << "' as " << (iqSwapValue?"swapped":"not swapped") << std::endl;
}
if (node->hasAnother("direct_sampling")) {
DataNode *direct_sampling_node = node->getNext("direct_sampling");
int directSamplingValue = 0;
direct_sampling_node->element()->get(directSamplingValue);
setDirectSampling(directSamplingValue);
std::cout << "Loaded Direct Sampling Mode for device '" << deviceId << "': ";
switch (directSamplingValue) {
case 0:
std::cout << "off" << std::endl;
break;
case 1:
std::cout << "I-ADC" << std::endl;
break;
case 2:
std::cout << "Q-ADC" << std::endl;
break;
}
}
if (node->hasAnother("offset")) {
DataNode *offset_node = node->getNext("offset");
long long offsetValue = 0;
offset_node->element()->get(offsetValue);
setOffset(offsetValue);
std::cout << "Loaded offset for device '" << deviceId << "' at " << offsetValue << "Hz" << std::endl;
}
busy_lock.unlock();
}
DeviceConfig *AppConfig::getDevice(std::string deviceId) {
DeviceConfig *conf = &deviceConfig[deviceId];
if (deviceConfig.find(deviceId) == deviceConfig.end()) {
deviceConfig[deviceId] = new DeviceConfig();
}
DeviceConfig *conf = deviceConfig[deviceId];
conf->setDeviceId(deviceId);
return conf;
}
@ -71,10 +148,10 @@ bool AppConfig::save() {
cfg.rootNode()->setName("cubicsdr_config");
DataNode *devices_node = cfg.rootNode()->newChild("devices");
std::map<std::string, DeviceConfig>::iterator device_config_i;
std::map<std::string, DeviceConfig *>::iterator device_config_i;
for (device_config_i = deviceConfig.begin(); device_config_i != deviceConfig.end(); device_config_i++) {
DataNode *device_node = devices_node->newChild("device");
device_config_i->second.save(device_node);
device_config_i->second->save(device_node);
}
std::string cfgFileDir = getConfigDir();

20
src/AppConfig.h
View File

@ -3,10 +3,11 @@
#include <wx/stdpaths.h>
#include <wx/dir.h>
#include <wx/filename.h>
#include <atomic>
#include <mutex>
#include "DataTree.h"
class DeviceConfig {
public:
DeviceConfig();
@ -14,7 +15,16 @@ public:
void setPPM(int ppm);
int getPPM();
void setDirectSampling(int mode);
int getDirectSampling();
void setOffset(long long offset);
long long getOffset();
void setIQSwap(bool iqSwap);
bool getIQSwap();
void setDeviceId(std::string deviceId);
std::string getDeviceId();
@ -23,7 +33,11 @@ public:
private:
std::string deviceId;
int ppm;
std::mutex busy_lock;
std::atomic_int ppm, directSampling;
std::atomic_bool iqSwap;
std::atomic_llong offset;
};
class AppConfig {
@ -36,5 +50,5 @@ public:
bool reset();
private:
std::map<std::string, DeviceConfig> deviceConfig;
std::map<std::string, DeviceConfig *> deviceConfig;
};

42
src/AppFrame.cpp
View File

@ -151,9 +151,9 @@ AppFrame::AppFrame() :
wxMenu *dsMenu = new wxMenu;
dsMenu->AppendRadioItem(wxID_SET_DS_OFF, "Off");
dsMenu->AppendRadioItem(wxID_SET_DS_I, "I-ADC");
dsMenu->AppendRadioItem(wxID_SET_DS_Q, "Q-ADC");
directSamplingMenuItems[0] = dsMenu->AppendRadioItem(wxID_SET_DS_OFF, "Off");
directSamplingMenuItems[1] = dsMenu->AppendRadioItem(wxID_SET_DS_I, "I-ADC");
directSamplingMenuItems[2] = dsMenu->AppendRadioItem(wxID_SET_DS_Q, "Q-ADC");
menu->AppendSubMenu(dsMenu, "Direct Sampling");
@ -328,6 +328,22 @@ AppFrame::~AppFrame() {
}
void AppFrame::initDeviceParams(std::string deviceId) {
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(deviceId);
int dsMode = devConfig->getDirectSampling();
if (dsMode > 0 && dsMode <= 2) {
directSamplingMenuItems[devConfig->getDirectSampling()]->Check();
}
if (devConfig->getIQSwap()) {
iqSwapMenuItem->Check();
}
}
void AppFrame::OnMenu(wxCommandEvent& event) {
if (event.GetId() >= wxID_RT_AUDIO_DEVICE && event.GetId() < wxID_RT_AUDIO_DEVICE + devices.size()) {
if (activeDemodulator) {
@ -448,7 +464,19 @@ void AppFrame::OnMenu(wxCommandEvent& event) {
std::vector<SDRDeviceInfo *> *devs = wxGetApp().getDevices();
if (event.GetId() >= wxID_DEVICE_ID && event.GetId() <= wxID_DEVICE_ID + devs->size()) {
wxGetApp().setDevice(event.GetId() - wxID_DEVICE_ID);
int devId = event.GetId() - wxID_DEVICE_ID;
wxGetApp().setDevice(devId);
SDRDeviceInfo *dev = (*wxGetApp().getDevices())[devId];
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
int dsMode = devConfig->getDirectSampling();
if (dsMode >= 0 && dsMode <= 2) {
directSamplingMenuItems[devConfig->getDirectSampling()]->Check();
}
iqSwapMenuItem->Check(devConfig->getIQSwap());
}
if (event.GetId() >= wxID_AUDIO_BANDWIDTH_BASE) {
@ -617,7 +645,6 @@ void AppFrame::saveSession(std::string fileName) {
DataNode *header = s.rootNode()->newChild("header");
*header->newChild("version") = std::string(CUBICSDR_VERSION);
*header->newChild("center_freq") = wxGetApp().getFrequency();
*header->newChild("offset") = wxGetApp().getOffset();
DataNode *demods = s.rootNode()->newChild("demodulators");
@ -656,14 +683,11 @@ bool AppFrame::loadSession(std::string fileName) {
std::string version(*header->getNext("version"));
long long center_freq = *header->getNext("center_freq");
long long offset = *header->getNext("offset");
std::cout << "Loading " << version << " session file" << std::endl;
std::cout << "\tCenter Frequency: " << center_freq << std::endl;
std::cout << "\tOffset: " << offset << std::endl;
wxGetApp().setFrequency(center_freq);
wxGetApp().setOffset(offset);
DataNode *demodulators = l.rootNode()->getNext("demodulators");
@ -711,7 +735,7 @@ bool AppFrame::loadSession(std::string fileName) {
}
newDemod->run();
newDemod->setActive(false);
wxGetApp().bindDemodulator(newDemod);
std::cout << "\tAdded demodulator at frequency " << freq << " type " << type << std::endl;

2
src/AppFrame.h
View File

@ -58,6 +58,7 @@ public:
~AppFrame();
void OnThread(wxCommandEvent& event);
void OnEventInput(wxThreadEvent& event);
void initDeviceParams(std::string deviceId);
void saveSession(std::string fileName);
bool loadSession(std::string fileName);
@ -86,6 +87,7 @@ private:
std::map<int, wxMenuItem *> outputDeviceMenuItems;
std::map<int, wxMenuItem *> sampleRateMenuItems;
std::map<int, wxMenuItem *> audioSampleRateMenuItems;
std::map<int, wxMenuItem *> directSamplingMenuItems;
wxMenuItem *iqSwapMenuItem;
std::string currentSessionFile;

45
src/CubicSDR.cpp
View File

@ -67,6 +67,7 @@ bool CubicSDR::OnInit() {
std::vector<SDRDeviceInfo *>::iterator devs_i;
SDRThread::enumerate_rtl(&devs);
SDRDeviceInfo *dev = NULL;
if (devs.size() > 1) {
wxArrayString choices;
@ -84,16 +85,36 @@ bool CubicSDR::OnInit() {
choices.Add(devName);
}
int devId = wxGetSingleChoiceIndex(wxT("Devices"), wxT("Choose Input Device"), choices);
int devId = wxGetSingleChoiceIndex(wxT("Devices"), wxT("Choose Input Device"), choices);
if (devId == -1) { // User chose to cancel
return false;
}
dev = devs[devId];
std::cout << "Chosen: " << devId << std::endl;
sdrThread->setDeviceId(devId);
} else if (devs.size() == 1) {
dev = devs[0];
}
if (!dev) {
wxMessageDialog *info;
info = new wxMessageDialog(NULL, wxT("\x28\u256F\xB0\u25A1\xB0\uFF09\u256F\uFE35\x20\u253B\u2501\u253B"), wxT("RTL-SDR device not found"), wxOK | wxICON_ERROR);
info->ShowModal();
return false;
}
t_PostSDR = new std::thread(&SDRPostThread::threadMain, sdrPostThread);
t_SDR = new std::thread(&SDRThread::threadMain, sdrThread);
appframe = new AppFrame();
if (dev != NULL) {
appframe->initDeviceParams(dev->getDeviceId());
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
ppm = devConfig->getPPM();
offset = devConfig->getOffset();
directSamplingMode = devConfig->getDirectSampling();
}
#ifdef __APPLE__
int main_policy;
@ -169,6 +190,10 @@ void CubicSDR::setOffset(long long ofs) {
SDRThreadCommand command(SDRThreadCommand::SDR_THREAD_CMD_SET_OFFSET);
command.llong_value = ofs;
threadCmdQueueSDR->push(command);
SDRDeviceInfo *dev = (*getDevices())[getDevice()];
config.getDevice(dev->getDeviceId())->setOffset(ofs);
config.save();
}
void CubicSDR::setDirectSampling(int mode) {
@ -176,6 +201,10 @@ void CubicSDR::setDirectSampling(int mode) {
SDRThreadCommand command(SDRThreadCommand::SDR_THREAD_CMD_SET_DIRECT_SAMPLING);
command.llong_value = mode;
threadCmdQueueSDR->push(command);
SDRDeviceInfo *dev = (*getDevices())[getDevice()];
config.getDevice(dev->getDeviceId())->setDirectSampling(mode);
config.save();
}
int CubicSDR::getDirectSampling() {
@ -184,6 +213,9 @@ int CubicSDR::getDirectSampling() {
void CubicSDR::setSwapIQ(bool swapIQ) {
sdrPostThread->setSwapIQ(swapIQ);
SDRDeviceInfo *dev = (*getDevices())[getDevice()];
config.getDevice(dev->getDeviceId())->setIQSwap(swapIQ);
config.save();
}
bool CubicSDR::getSwapIQ() {
@ -244,11 +276,12 @@ void CubicSDR::setDevice(int deviceId) {
threadCmdQueueSDR->push(command);
SDRDeviceInfo *dev = (*getDevices())[deviceId];
DeviceConfig *devConfig = config.getDevice(dev->getDeviceId());
SDRThreadCommand command_ppm(SDRThreadCommand::SDR_THREAD_CMD_SET_PPM);
ppm = config.getDevice(dev->getDeviceId())->getPPM();
command_ppm.llong_value = ppm;
threadCmdQueueSDR->push(command_ppm);
setPPM(devConfig->getPPM());
setDirectSampling(devConfig->getDirectSampling());
setSwapIQ(devConfig->getIQSwap());
setOffset(devConfig->getOffset());
}
int CubicSDR::getDevice() {

41
src/sdr/SDRThread.cpp
View File

@ -6,7 +6,7 @@
SDRThread::SDRThread(SDRThreadCommandQueue* pQueue) :
commandQueue(pQueue), iqDataOutQueue(NULL), terminated(false), offset(0), deviceId(-1) {
dev = NULL;
sampleRate = DEFAULT_SAMPLE_RATE;
sampleRate.store(DEFAULT_SAMPLE_RATE);
}
SDRThread::~SDRThread() {
@ -122,6 +122,7 @@ void SDRThread::threadMain() {
std::cout << "SDR thread initializing.." << std::endl;
int devCount = rtlsdr_get_device_count();
std::vector<SDRDeviceInfo *> devs;
if (deviceId == -1) {
deviceId = enumerate_rtl(&devs);
@ -136,16 +137,20 @@ void SDRThread::threadMain() {
std::cout << "Using device #" << deviceId << std::endl;
}
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(devs[deviceId]->getDeviceId());
signed char buf[BUF_SIZE];
long long frequency = DEFAULT_FREQ;
int ppm = wxGetApp().getConfig()->getDevice(devs[deviceId]->getDeviceId())->getPPM();
int direct_sampling_mode = 0;
int ppm = devConfig->getPPM();
int direct_sampling_mode = devConfig->getDirectSampling();;
int buf_size = BUF_SIZE;
offset.store(devConfig->getOffset());
wxGetApp().setSwapIQ(devConfig->getIQSwap());
rtlsdr_open(&dev, deviceId);
rtlsdr_set_sample_rate(dev, sampleRate);
rtlsdr_set_center_freq(dev, frequency - offset);
rtlsdr_set_sample_rate(dev, sampleRate.load());
rtlsdr_set_center_freq(dev, frequency - offset.load());
rtlsdr_set_freq_correction(dev, ppm);
rtlsdr_set_agc_mode(dev, 1);
rtlsdr_set_offset_tuning(dev, 0);
@ -153,7 +158,7 @@ void SDRThread::threadMain() {
// sampleRate = rtlsdr_get_sample_rate(dev);
std::cout << "Sample Rate is: " << sampleRate << std::endl;
std::cout << "Sample Rate is: " << sampleRate.load() << std::endl;
int n_read;
double seconds = 0.0;
@ -174,8 +179,8 @@ void SDRThread::threadMain() {
bool ppm_changed = false;
bool direct_sampling_changed = false;
long long new_freq = frequency;
long long new_offset = offset;
long long new_rate = sampleRate;
long long new_offset = offset.load();
long long new_rate = sampleRate.load();
int new_device = deviceId;
int new_ppm = ppm;
@ -187,8 +192,8 @@ void SDRThread::threadMain() {
case SDRThreadCommand::SDR_THREAD_CMD_TUNE:
freq_changed = true;
new_freq = command.llong_value;
if (new_freq < sampleRate / 2) {
new_freq = sampleRate / 2;
if (new_freq < sampleRate.load() / 2) {
new_freq = sampleRate.load() / 2;
}
// std::cout << "Set frequency: " << new_freq << std::endl;
break;
@ -231,8 +236,8 @@ void SDRThread::threadMain() {
if (device_changed) {
rtlsdr_close(dev);
rtlsdr_open(&dev, new_device);
rtlsdr_set_sample_rate(dev, sampleRate);
rtlsdr_set_center_freq(dev, frequency - offset);
rtlsdr_set_sample_rate(dev, sampleRate.load());
rtlsdr_set_center_freq(dev, frequency - offset.load());
rtlsdr_set_freq_correction(dev, ppm);
rtlsdr_set_agc_mode(dev, 1);
rtlsdr_set_offset_tuning(dev, 0);
@ -244,16 +249,16 @@ void SDRThread::threadMain() {
new_freq = frequency;
freq_changed = true;
}
offset = new_offset;
offset.store(new_offset);
}
if (rate_changed) {
rtlsdr_set_sample_rate(dev, new_rate);
rtlsdr_reset_buffer(dev);
sampleRate = rtlsdr_get_sample_rate(dev);
sampleRate.store(rtlsdr_get_sample_rate(dev));
}
if (freq_changed) {
frequency = new_freq;
rtlsdr_set_center_freq(dev, frequency - offset);
rtlsdr_set_center_freq(dev, frequency - offset.load());
}
if (ppm_changed) {
ppm = new_ppm;
@ -283,7 +288,7 @@ void SDRThread::threadMain() {
// std::lock_guard < std::mutex > lock(dataOut->m_mutex);
dataOut->setRefCount(1);
dataOut->frequency = frequency;
dataOut->sampleRate = sampleRate;
dataOut->sampleRate = sampleRate.load();
if (dataOut->data.capacity() < n_read) {
dataOut->data.reserve(n_read);
@ -295,7 +300,7 @@ void SDRThread::threadMain() {
memcpy(&dataOut->data[0], buf, n_read);
double time_slice = (double) n_read / (double) sampleRate;
double time_slice = (double) n_read / (double) sampleRate.load();
seconds += time_slice;
if (iqDataOutQueue.load() != NULL) {

10
src/sdr/SDRThread.h
View File

@ -140,19 +140,19 @@ public:
void terminate();
int getDeviceId() const {
return deviceId;
return deviceId.load();
}
void setDeviceId(int deviceId) {
this->deviceId = deviceId;
this->deviceId.store(deviceId);
}
protected:
uint32_t sampleRate;
long long offset;
std::atomic<uint32_t> sampleRate;
std::atomic<long long> offset;
std::atomic<SDRThreadCommandQueue*> commandQueue;
std::atomic<SDRThreadIQDataQueue*> iqDataOutQueue;
std::atomic<bool> terminated;
int deviceId;
std::atomic<int> deviceId;
};