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

RTL Device Selection

This commit is contained in:
Charles J. Cliffe 2015-01-12 00:40:43 -05:00
parent 2b6da304ef
commit 2d0485c8ea
6 changed files with 208 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/AppFrame.cpp
View File

@ -187,6 +187,33 @@ AppFrame::AppFrame() :
menuBar->Append(menu, wxT("&Input Bandwidth"));
std::vector<SDRDeviceInfo *> *devs = wxGetApp().getDevices();
std::vector<SDRDeviceInfo *>::iterator devs_i;
if (devs->size() > 1) {
menu = new wxMenu;
int p = 0;
for (devs_i = devs->begin(); devs_i != devs->end(); devs_i++) {
std::string devName = (*devs_i)->getName();
if ((*devs_i)->isAvailable()) {
devName.append(": ");
devName.append((*devs_i)->getProduct());
devName.append(" [");
devName.append((*devs_i)->getSerial());
devName.append("]");
} else {
devName.append(" (In Use?)");
}
menu->Append(wxID_DEVICE_ID+p, devName);
p++;
}
menuBar->Append(menu,wxT("&Device"));
}
SetMenuBar(menuBar);
CreateStatusBar();
@ -298,6 +325,11 @@ void AppFrame::OnMenu(wxCommandEvent& event) {
wxGetApp().setSampleRate(3200000);
break;
}
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);
}
}
void AppFrame::OnClose(wxCommandEvent& WXUNUSED(event)) {

3
src/AppFrame.h
View File

@ -31,6 +31,9 @@
#define wxID_BANDWIDTH_2880M 2156
#define wxID_BANDWIDTH_3200M 2158
#define wxID_DEVICE_ID 3500
// Define a new frame type
class AppFrame: public wxFrame {
public:

37
src/CubicSDR.cpp
View File

@ -39,6 +39,32 @@ bool CubicSDR::OnInit() {
sdrPostThread->setIQDataInQueue(iqPostDataQueue);
sdrPostThread->setIQVisualQueue(iqVisualQueue);
std::vector<SDRDeviceInfo *>::iterator devs_i;
SDRThread::enumerate_rtl(&devs);
if (devs.size() > 1) {
wxArrayString choices;
for (devs_i = devs.begin(); devs_i != devs.end(); devs_i++) {
std::string devName = (*devs_i)->getName();
if ((*devs_i)->isAvailable()) {
devName.append(": ");
devName.append((*devs_i)->getProduct());
devName.append(" [");
devName.append((*devs_i)->getSerial());
devName.append("]");
} else {
devName.append(" (In Use?)");
}
choices.Add(devName);
}
int devId = wxGetSingleChoiceIndex(wxT("Devices"),wxT("Choose Input Device"),choices);
std::cout << "Chosen: " << devId << std::endl;
sdrThread->setDeviceId(devId);
}
t_PostSDR = new std::thread(&SDRPostThread::threadMain, sdrPostThread);
t_SDR = new std::thread(&SDRThread::threadMain, sdrThread);
@ -163,3 +189,14 @@ void CubicSDR::removeDemodulator(DemodulatorInstance *demod) {
}
sdrPostThread->removeDemodulator(demod);
}
std::vector<SDRDeviceInfo*>* CubicSDR::getDevices() {
return &devs;
}
void CubicSDR::setDevice(int deviceId) {
sdrThread->setDeviceId(deviceId);
SDRThreadCommand command(SDRThreadCommand::SDR_THREAD_CMD_SET_DEVICE);
command.llong_value = deviceId;
threadCmdQueueSDR->push(command);
}

4
src/CubicSDR.h
View File

@ -38,6 +38,9 @@ public:
void setSampleRate(long long rate_in);
long long getSampleRate();
std::vector<SDRDeviceInfo *> *getDevices();
void setDevice(int deviceId);
DemodulatorThreadOutputQueue* getAudioVisualQueue();
DemodulatorThreadInputQueue* getIQVisualQueue();
DemodulatorMgr &getDemodMgr();
@ -47,6 +50,7 @@ public:
private:
PrimaryGLContext *m_glContext;
std::vector<SDRDeviceInfo *> devs;
DemodulatorMgr demodMgr;

77
src/sdr/SDRThread.cpp
View File

@ -4,7 +4,7 @@
#include "CubicSDR.h"
SDRThread::SDRThread(SDRThreadCommandQueue* pQueue) :
commandQueue(pQueue), iqDataOutQueue(NULL), terminated(false), offset(0) {
commandQueue(pQueue), iqDataOutQueue(NULL), terminated(false), offset(0), deviceId(-1) {
dev = NULL;
sampleRate = DEFAULT_SAMPLE_RATE;
}
@ -13,7 +13,7 @@ SDRThread::~SDRThread() {
rtlsdr_close(dev);
}
int SDRThread::enumerate_rtl() {
int SDRThread::enumerate_rtl(std::vector<SDRDeviceInfo *> *devs) {
int first_available = -1;
@ -24,37 +24,51 @@ int SDRThread::enumerate_rtl() {
std::cout << "RTL Devices: " << rtl_count << std::endl;
for (int i = 0; i < rtl_count; i++) {
std::cout << "Device #" << i << ": " << rtlsdr_get_device_name(i) << std::endl;
std::string deviceName(rtlsdr_get_device_name(i));
std::string deviceManufacturer;
std::string deviceProduct;
std::string deviceTuner;
std::string deviceSerial;
bool deviceAvailable = false;
std::cout << "Device #" << i << ": " << deviceName << std::endl;
if (rtlsdr_get_device_usb_strings(i, manufact, product, serial) == 0) {
std::cout << "\tManufacturer: " << manufact << ", Product Name: " << product << ", Serial: " << serial << std::endl;
rtlsdr_open(&dev, i);
deviceSerial = serial;
deviceAvailable = true;
deviceProduct = product;
deviceManufacturer = manufact;
rtlsdr_dev_t *devTest;
rtlsdr_open(&devTest, i);
std::cout << "\t Tuner type: ";
switch (rtlsdr_get_tuner_type(dev)) {
switch (rtlsdr_get_tuner_type(devTest)) {
case RTLSDR_TUNER_UNKNOWN:
std::cout << "Unknown";
deviceTuner = "Unknown";
break;
case RTLSDR_TUNER_E4000:
std::cout << "Elonics E4000";
deviceTuner = "Elonics E4000";
break;
case RTLSDR_TUNER_FC0012:
std::cout << "Fitipower FC0012";
deviceTuner = "Fitipower FC0012";
break;
case RTLSDR_TUNER_FC0013:
std::cout << "Fitipower FC0013";
deviceTuner = "Fitipower FC0013";
break;
case RTLSDR_TUNER_FC2580:
std::cout << "Fitipower FC2580";
deviceTuner = "Fitipower FC2580";
break;
case RTLSDR_TUNER_R820T:
std::cout << "Rafael Micro R820T";
deviceTuner = "Rafael Micro R820T";
break;
case RTLSDR_TUNER_R828D:
deviceTuner = "Rafael Micro R828D";
break;
}
std::cout << std::endl;
std::cout << deviceTuner << std::endl;
/*
int num_gains = rtlsdr_get_tuner_gains(dev, NULL);
@ -73,7 +87,7 @@ int SDRThread::enumerate_rtl() {
free(gains);
*/
rtlsdr_close(dev);
rtlsdr_close(devTest);
if (first_available == -1) {
first_available = i;
}
@ -82,6 +96,15 @@ int SDRThread::enumerate_rtl() {
std::cout << "\tUnable to access device #" << i << " (in use?)" << std::endl;
}
if (devs != NULL) {
SDRDeviceInfo *devInfo = new SDRDeviceInfo();
devInfo->setName(deviceName);
devInfo->setAvailable(deviceAvailable);
devInfo->setProduct(deviceProduct);
devInfo->setSerial(deviceSerial);
devInfo->setManufacturer(deviceManufacturer);
devs->push_back(devInfo);
}
}
return first_available;
@ -92,27 +115,29 @@ void SDRThread::threadMain() {
#ifdef __APPLE__
pthread_t tID = pthread_self(); // ID of this thread
int priority = sched_get_priority_max( SCHED_FIFO) - 1;
sched_param prio = {priority}; // scheduling priority of thread
sched_param prio = { priority }; // scheduling priority of thread
pthread_setschedparam(tID, SCHED_FIFO, &prio);
#endif
std::cout << "SDR thread initializing.." << std::endl;
int devCount = rtlsdr_get_device_count();
int firstDevAvailable = enumerate_rtl();
if (deviceId == -1) {
deviceId = enumerate_rtl(NULL);
}
if (firstDevAvailable == -1) {
if (deviceId == -1) {
std::cout << "No devices found.. SDR Thread exiting.." << std::endl;
return;
} else {
std::cout << "Using first available RTL-SDR device #" << firstDevAvailable << std::endl;
std::cout << "Using device #" << deviceId << std::endl;
}
signed char buf[BUF_SIZE];
long long frequency = DEFAULT_FREQ;
rtlsdr_open(&dev, firstDevAvailable);
rtlsdr_open(&dev, deviceId);
rtlsdr_set_sample_rate(dev, sampleRate);
rtlsdr_set_center_freq(dev, frequency - offset);
rtlsdr_set_agc_mode(dev, 1);
@ -138,9 +163,11 @@ void SDRThread::threadMain() {
bool freq_changed = false;
bool offset_changed = false;
bool rate_changed = false;
bool device_changed = false;
long long new_freq;
long long new_offset;
long long new_rate;
int new_device;
while (!cmdQueue->empty()) {
SDRThreadCommand command;
@ -165,11 +192,25 @@ void SDRThread::threadMain() {
new_rate = command.llong_value;
std::cout << "Set sample rate: " << new_rate << std::endl;
break;
case SDRThreadCommand::SDR_THREAD_CMD_SET_DEVICE:
device_changed = true;
new_device = (int) command.llong_value;
std::cout << "Set device: " << new_device << std::endl;
break;
default:
break;
}
}
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_agc_mode(dev, 1);
rtlsdr_set_offset_tuning(dev, 0);
rtlsdr_reset_buffer(dev);
}
if (offset_changed && !freq_changed) {
new_freq = frequency;
freq_changed = true;

75
src/sdr/SDRThread.h
View File

@ -14,10 +14,71 @@
#include "ThreadQueue.h"
#include "DemodulatorMgr.h"
class SDRDeviceInfo {
public:
SDRDeviceInfo() : name(""), serial(""), available(false) { }
bool isAvailable() const {
return available;
}
void setAvailable(bool available) {
this->available = available;
}
const std::string& getName() const {
return name;
}
void setName(const std::string& name) {
this->name = name;
}
const std::string& getSerial() const {
return serial;
}
void setSerial(const std::string& serial) {
this->serial = serial;
}
const std::string& getTuner() const {
return tuner;
}
void setTuner(const std::string& tuner) {
this->tuner = tuner;
}
const std::string& getManufacturer() const {
return manufacturer;
}
void setManufacturer(const std::string& manufacturer) {
this->manufacturer = manufacturer;
}
const std::string& getProduct() const {
return product;
}
void setProduct(const std::string& product) {
this->product = product;
}
private:
std::string name;
std::string serial;
std::string product;
std::string manufacturer;
std::string tuner;
bool available;
};
class SDRThreadCommand {
public:
enum SDRThreadCommandEnum {
SDR_THREAD_CMD_NULL, SDR_THREAD_CMD_TUNE, SDR_THREAD_CMD_SET_OFFSET, SDR_THREAD_CMD_SET_SAMPLERATE
SDR_THREAD_CMD_NULL, SDR_THREAD_CMD_TUNE, SDR_THREAD_CMD_SET_OFFSET, SDR_THREAD_CMD_SET_SAMPLERATE, SDR_THREAD_CMD_SET_DEVICE
};
SDRThreadCommand() :
@ -65,7 +126,7 @@ public:
SDRThread(SDRThreadCommandQueue* pQueue);
~SDRThread();
int enumerate_rtl();
static int enumerate_rtl(std::vector<SDRDeviceInfo *> *devs);
void threadMain();
@ -74,6 +135,15 @@ public:
}
void terminate();
int getDeviceId() const {
return deviceId;
}
void setDeviceId(int deviceId) {
this->deviceId = deviceId;
}
protected:
uint32_t sampleRate;
long long offset;
@ -81,4 +151,5 @@ protected:
std::atomic<SDRThreadIQDataQueue*> iqDataOutQueue;
std::atomic<bool> terminated;
int deviceId;
};