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

Save offset, direct sampling mode and i/q swap per device

This commit is contained in:
Charles J. Cliffe 2015-07-08 01:07:39 -04:00
parent dbc85d4f29
commit b762d4d118
7 changed files with 151 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/AppConfig.cpp
View File

@ -1,6 +1,7 @@
#include "AppConfig.h"
#include "CubicSDR.h"
DeviceConfig::DeviceConfig() : ppm(0), deviceId("") {
DeviceConfig::DeviceConfig() : deviceId(""), ppm(0), directSampling(false), offset(0) {
}
@ -16,6 +17,30 @@ int DeviceConfig::getPPM() {
return ppm;
}
void DeviceConfig::setDirectSampling(int mode) {
directSampling = mode;
}
int DeviceConfig::getDirectSampling() {
return directSampling;
}
void DeviceConfig::setOffset(long long offset) {
this->offset = offset;
}
long long DeviceConfig::getOffset() {
return offset;
}
void DeviceConfig::setIQSwap(bool iqSwap) {
this->iqSwap = iqSwap;
}
bool DeviceConfig::getIQSwap() {
return iqSwap;
}
void DeviceConfig::setDeviceId(std::string deviceId) {
this->deviceId = deviceId;
}
@ -25,9 +50,11 @@ std::string DeviceConfig::getDeviceId() {
}
void DeviceConfig::save(DataNode *node) {
node->newChild("id")->element()->set(deviceId);
DataNode *ppm_node = node->newChild("ppm");
ppm_node->element()->set((int)ppm);
*node->newChild("id") = deviceId;
*node->newChild("ppm") = (int)ppm;
*node->newChild("iq_swap") = iqSwap;
*node->newChild("direct_sampling") = directSampling;
*node->newChild("offset") = offset;
}
void DeviceConfig::load(DataNode *node) {
@ -38,6 +65,39 @@ 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 << "ppm" << std::endl;
}
}

13
src/AppConfig.h
View File

@ -14,7 +14,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 +32,9 @@ public:
private:
std::string deviceId;
int ppm;
int ppm, directSampling;
bool iqSwap;
long long offset;
};
class AppConfig {

34
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");
@ -319,6 +319,20 @@ AppFrame::AppFrame() :
wxAcceleratorTable accel(3, entries);
SetAcceleratorTable(accel);
SDRDeviceInfo *dev = (*wxGetApp().getDevices())[wxGetApp().getDevice()];
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
int dsMode = devConfig->getDirectSampling();
if (dsMode > 0 && dsMode <= 2) {
directSamplingMenuItems[devConfig->getDirectSampling()]->Check();
}
if (devConfig->getIQSwap()) {
iqSwapMenuItem->Check();
}
// static const int attribs[] = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, 0 };
// wxLogStatus("Double-buffered display %s supported", wxGLCanvas::IsDisplaySupported(attribs) ? "is" : "not");
// ShowFullScreen(true);
@ -448,7 +462,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) {

1
src/AppFrame.h
View File

@ -86,6 +86,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;

20
src/CubicSDR.cpp
View File

@ -169,6 +169,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 +180,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 +192,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 +255,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;
};