2014-10-27 20:05:40 -04:00
# define OPENGL
2015-02-17 21:26:14 -05:00
# include "CubicSDRDefs.h"
2014-10-27 20:05:40 -04:00
# include "wx/wxprec.h"
# ifndef WX_PRECOMP
# include "wx/wx.h"
# endif
# if !wxUSE_GLCANVAS
# error "OpenGL required: set wxUSE_GLCANVAS to 1 and rebuild the library"
# endif
2014-10-27 21:22:29 -04:00
# include "CubicSDR.h"
2015-10-20 23:00:10 -04:00
# include <iomanip>
2014-10-27 20:05:40 -04:00
2015-02-17 21:26:14 -05:00
# ifdef _OSX_APP_
# include "CoreFoundation/CoreFoundation.h"
# endif
2014-10-27 20:05:40 -04:00
IMPLEMENT_APP ( CubicSDR )
2015-11-28 23:03:07 -05:00
//#ifdef ENABLE_DIGITAL_LAB
//// console output buffer for windows
//#ifdef _WINDOWS
//class outbuf : public std::streambuf {
// public:
// outbuf() {
// setp(0, 0);
// }
// virtual int_type overflow(int_type c = traits_type::eof()) {
// return fputc(c, stdout) == EOF ? traits_type::eof() : c;
// }
//};
//#endif
//#endif
2015-06-10 14:48:05 -04:00
2015-10-19 23:02:50 -04:00
# ifdef MINGW_PATCH
FILE _iob [ ] = { * stdin , * stdout , * stderr } ;
2015-07-30 21:53:29 -04:00
2015-10-19 23:02:50 -04:00
extern " C " FILE * __cdecl __iob_func ( void )
{
return _iob ;
}
extern " C " int __cdecl __isnan ( double x )
{
return _finite ( x ) ? 0 : 1 ;
}
extern " C " int __cdecl __isnanf ( float x )
{
return _finitef ( x ) ? 0 : 1 ;
}
# endif
2015-10-20 23:00:10 -04:00
std : : string & filterChars ( std : : string & s , const std : : string & allowed ) {
s . erase ( remove_if ( s . begin ( ) , s . end ( ) , [ & allowed ] ( const char & c ) {
return allowed . find ( c ) = = std : : string : : npos ;
} ) , s . end ( ) ) ;
return s ;
}
std : : string frequencyToStr ( long long freq ) {
long double freqTemp ;
freqTemp = freq ;
std : : string suffix ( " " ) ;
std : : stringstream freqStr ;
2015-07-27 21:45:24 -04:00
2015-10-20 23:00:10 -04:00
if ( freqTemp > = 1.0e9 ) {
freqTemp / = 1.0e9 ;
freqStr < < std : : setprecision ( 10 ) ;
suffix = std : : string ( " GHz " ) ;
} else if ( freqTemp > = 1.0e6 ) {
freqTemp / = 1.0e6 ;
freqStr < < std : : setprecision ( 7 ) ;
suffix = std : : string ( " MHz " ) ;
} else if ( freqTemp > = 1.0e3 ) {
freqTemp / = 1.0e3 ;
freqStr < < std : : setprecision ( 4 ) ;
suffix = std : : string ( " KHz " ) ;
}
freqStr < < freqTemp ;
freqStr < < suffix ;
return freqStr . str ( ) ;
}
long long strToFrequency ( std : : string freqStr ) {
std : : string filterStr = filterChars ( freqStr , std : : string ( " 0123456789.MKGHmkgh " ) ) ;
int numLen = filterStr . find_first_not_of ( " 0123456789. " ) ;
if ( numLen = = std : : string : : npos ) {
numLen = freqStr . length ( ) ;
}
std : : string numPartStr = freqStr . substr ( 0 , numLen ) ;
std : : string suffixStr = freqStr . substr ( numLen ) ;
std : : stringstream numPartStream ;
numPartStream . str ( numPartStr ) ;
long double freqTemp = 0 ;
numPartStream > > freqTemp ;
if ( suffixStr . length ( ) ) {
if ( suffixStr . find_first_of ( " Gg " ) ! = std : : string : : npos ) {
freqTemp * = 1.0e9 ;
} else if ( suffixStr . find_first_of ( " Mm " ) ! = std : : string : : npos ) {
freqTemp * = 1.0e6 ;
} else if ( suffixStr . find_first_of ( " Kk " ) ! = std : : string : : npos ) {
freqTemp * = 1.0e3 ;
} else if ( suffixStr . find_first_of ( " Hh " ) ! = std : : string : : npos ) {
// ...
}
} else if ( numPartStr . find_first_of ( " . " ) ! = std : : string : : npos | | freqTemp < = 3000 ) {
freqTemp * = 1.0e6 ;
}
return ( long long ) freqTemp ;
}
2015-11-02 19:02:45 -05:00
CubicSDR : : CubicSDR ( ) : appframe ( NULL ) , m_glContext ( NULL ) , frequency ( 0 ) , offset ( 0 ) , ppm ( 0 ) , snap ( 1 ) , sampleRate ( DEFAULT_SAMPLE_RATE ) ,
2015-10-03 21:35:11 -04:00
sdrThread ( NULL ) , sdrPostThread ( NULL ) , spectrumVisualThread ( NULL ) , demodVisualThread ( NULL ) , pipeSDRIQData ( NULL ) , pipeIQVisualData ( NULL ) , pipeAudioVisualData ( NULL ) , t_SDR ( NULL ) , t_PostSDR ( NULL ) {
2015-10-21 16:56:32 -04:00
sampleRateInitialized . store ( false ) ;
2015-10-27 01:56:49 -04:00
agcMode . store ( true ) ;
2015-07-27 21:45:24 -04:00
}
2014-10-27 20:05:40 -04:00
bool CubicSDR : : OnInit ( ) {
2015-02-17 21:26:14 -05:00
# ifdef _OSX_APP_
CFBundleRef mainBundle = CFBundleGetMainBundle ( ) ;
CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL ( mainBundle ) ;
char path [ PATH_MAX ] ;
if ( ! CFURLGetFileSystemRepresentation ( resourcesURL , TRUE , ( UInt8 * ) path , PATH_MAX ) )
{
// error!
}
CFRelease ( resourcesURL ) ;
chdir ( path ) ;
# endif
2015-04-13 21:18:45 -04:00
2015-04-13 19:58:34 -04:00
if ( ! wxApp : : OnInit ( ) ) {
2014-10-27 20:05:40 -04:00
return false ;
2015-04-13 19:58:34 -04:00
}
2015-11-28 23:03:07 -05:00
//#ifdef ENABLE_DIGITAL_LAB
// // console output for windows
// #ifdef _WINDOWS
// if (AllocConsole()) {
// freopen("CONOUT$", "w", stdout);
// SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED);
// }
// outbuf ob;
// std::streambuf *sb = std::cout.rdbuf(&ob);
// std::cout.rdbuf(sb);
// #endif
//#endif
2015-11-15 13:52:54 -05:00
2015-04-21 23:19:45 -04:00
wxApp : : SetAppName ( " CubicSDR " ) ;
2015-04-13 19:58:34 -04:00
2015-11-18 23:40:30 -05:00
Modem : : addModemFactory ( new ModemFM ) ;
Modem : : addModemFactory ( new ModemFMStereo ) ;
Modem : : addModemFactory ( new ModemAM ) ;
Modem : : addModemFactory ( new ModemLSB ) ;
Modem : : addModemFactory ( new ModemUSB ) ;
Modem : : addModemFactory ( new ModemDSB ) ;
Modem : : addModemFactory ( new ModemIQ ) ;
2015-11-22 19:56:25 -05:00
# ifdef ENABLE_DIGITAL_LAB
2015-11-18 23:40:30 -05:00
Modem : : addModemFactory ( new ModemAPSK ) ;
Modem : : addModemFactory ( new ModemASK ) ;
Modem : : addModemFactory ( new ModemBPSK ) ;
Modem : : addModemFactory ( new ModemDPSK ) ;
2015-12-01 22:06:50 -05:00
# if ENABLE_LIQUID_EXPERIMENTAL
2015-11-22 19:56:25 -05:00
Modem : : addModemFactory ( new ModemFSK ) ;
2015-12-01 22:06:50 -05:00
# endif
2015-11-30 21:58:54 -05:00
Modem : : addModemFactory ( new ModemGMSK ) ;
2015-11-18 23:40:30 -05:00
Modem : : addModemFactory ( new ModemOOK ) ;
Modem : : addModemFactory ( new ModemPSK ) ;
Modem : : addModemFactory ( new ModemQAM ) ;
Modem : : addModemFactory ( new ModemQPSK ) ;
Modem : : addModemFactory ( new ModemSQAM ) ;
Modem : : addModemFactory ( new ModemST ) ;
2015-11-22 19:56:25 -05:00
# endif
2015-07-21 00:04:04 -04:00
frequency = wxGetApp ( ) . getConfig ( ) - > getCenterFreq ( ) ;
2015-01-06 00:57:57 -05:00
offset = 0 ;
2015-04-13 21:18:45 -04:00
ppm = 0 ;
2015-10-05 02:21:08 -04:00
devicesReady . store ( false ) ;
deviceSelectorOpen . store ( false ) ;
2014-11-23 19:39:27 -05:00
2015-07-30 19:30:46 -04:00
// Visual Data
2015-08-16 18:12:12 -04:00
spectrumVisualThread = new SpectrumVisualDataThread ( ) ;
demodVisualThread = new SpectrumVisualDataThread ( ) ;
2015-07-30 20:36:06 -04:00
pipeIQVisualData = new DemodulatorThreadInputQueue ( ) ;
pipeIQVisualData - > set_max_num_items ( 1 ) ;
2015-08-03 01:38:38 -04:00
pipeDemodIQVisualData = new DemodulatorThreadInputQueue ( ) ;
2015-08-11 22:11:54 -04:00
pipeDemodIQVisualData - > set_max_num_items ( 1 ) ;
2015-08-03 01:38:38 -04:00
2015-08-11 00:50:43 -04:00
pipeWaterfallIQVisualData = new DemodulatorThreadInputQueue ( ) ;
2015-09-10 23:42:22 -04:00
pipeWaterfallIQVisualData - > set_max_num_items ( 128 ) ;
2015-08-03 01:38:38 -04:00
2015-08-16 18:12:12 -04:00
getDemodSpectrumProcessor ( ) - > setInput ( pipeDemodIQVisualData ) ;
2015-10-17 16:17:12 -04:00
getSpectrumProcessor ( ) - > setInput ( pipeIQVisualData ) ;
2015-11-03 00:53:39 -05:00
getSpectrumProcessor ( ) - > setHideDC ( true ) ;
2015-07-30 19:30:46 -04:00
2015-07-30 20:36:06 -04:00
pipeAudioVisualData = new DemodulatorThreadOutputQueue ( ) ;
pipeAudioVisualData - > set_max_num_items ( 1 ) ;
2015-07-30 19:30:46 -04:00
2015-08-01 11:03:00 -04:00
scopeProcessor . setInput ( pipeAudioVisualData ) ;
2015-07-30 19:30:46 -04:00
// I/Q Data
2015-08-12 21:45:02 -04:00
pipeSDRIQData = new SDRThreadIQDataQueue ( ) ;
2015-08-16 18:12:12 -04:00
pipeSDRIQData - > set_max_num_items ( 100 ) ;
2015-08-12 21:45:02 -04:00
2015-07-29 22:01:13 -04:00
sdrThread = new SDRThread ( ) ;
2015-07-30 20:36:06 -04:00
sdrThread - > setOutputQueue ( " IQDataOutput " , pipeSDRIQData ) ;
2014-11-23 19:39:27 -05:00
2014-11-29 13:58:20 -05:00
sdrPostThread = new SDRPostThread ( ) ;
2015-07-30 20:36:06 -04:00
sdrPostThread - > setInputQueue ( " IQDataInput " , pipeSDRIQData ) ;
2015-08-11 00:50:43 -04:00
sdrPostThread - > setOutputQueue ( " IQVisualDataOutput " , pipeIQVisualData ) ;
sdrPostThread - > setOutputQueue ( " IQDataOutput " , pipeWaterfallIQVisualData ) ;
2015-10-17 16:17:12 -04:00
sdrPostThread - > setOutputQueue ( " IQActiveDemodVisualDataOutput " , pipeDemodIQVisualData ) ;
2015-05-27 05:08:47 -04:00
2014-11-30 17:11:29 -05:00
t_PostSDR = new std : : thread ( & SDRPostThread : : threadMain , sdrPostThread ) ;
2015-08-16 18:12:12 -04:00
t_SpectrumVisual = new std : : thread ( & SpectrumVisualDataThread : : threadMain , spectrumVisualThread ) ;
t_DemodVisual = new std : : thread ( & SpectrumVisualDataThread : : threadMain , demodVisualThread ) ;
2014-11-23 19:39:27 -05:00
2015-10-04 16:07:14 -04:00
sdrEnum = new SDREnumerator ( ) ;
2014-12-04 22:25:18 -05:00
2015-10-09 19:42:52 -04:00
appframe = new AppFrame ( ) ;
2015-10-10 01:13:48 -04:00
t_SDREnum = new std : : thread ( & SDREnumerator : : threadMain , sdrEnum ) ;
2015-10-09 19:42:52 -04:00
2015-10-05 02:21:08 -04:00
//#ifdef __APPLE__
// int main_policy;
// struct sched_param main_param;
//
// main_policy = SCHED_RR;
// main_param.sched_priority = sched_get_priority_min(SCHED_RR)+2;
//
// pthread_setschedparam(pthread_self(), main_policy, &main_param);
//#endif
2014-12-04 22:25:18 -05:00
2014-10-27 20:05:40 -04:00
return true ;
}
int CubicSDR : : OnExit ( ) {
2015-05-31 12:05:45 -04:00
demodMgr . terminateAll ( ) ;
2014-11-23 19:39:27 -05:00
std : : cout < < " Terminating SDR thread.. " < < std : : endl ;
2015-10-03 21:35:11 -04:00
if ( ! sdrThread - > isTerminated ( ) ) {
sdrThread - > terminate ( ) ;
2015-10-04 16:07:14 -04:00
if ( t_SDR ) {
t_SDR - > join ( ) ;
}
2015-10-03 21:35:11 -04:00
}
2014-11-30 17:11:29 -05:00
std : : cout < < " Terminating SDR post-processing thread.. " < < std : : endl ;
2014-11-29 13:58:20 -05:00
sdrPostThread - > terminate ( ) ;
2014-11-30 17:11:29 -05:00
t_PostSDR - > join ( ) ;
2015-08-16 18:12:12 -04:00
std : : cout < < " Terminating Visual Processor threads.. " < < std : : endl ;
spectrumVisualThread - > terminate ( ) ;
t_SpectrumVisual - > join ( ) ;
demodVisualThread - > terminate ( ) ;
t_DemodVisual - > join ( ) ;
2014-11-29 13:58:20 -05:00
2014-11-23 19:39:27 -05:00
delete sdrThread ;
2014-11-29 13:58:20 -05:00
delete sdrPostThread ;
2014-11-30 17:11:29 -05:00
delete t_PostSDR ;
2014-11-29 13:58:20 -05:00
2015-08-16 18:12:12 -04:00
delete t_SpectrumVisual ;
delete spectrumVisualThread ;
delete t_DemodVisual ;
delete demodVisualThread ;
2015-07-30 20:36:06 -04:00
delete pipeIQVisualData ;
delete pipeAudioVisualData ;
delete pipeSDRIQData ;
2014-11-29 13:58:20 -05:00
2014-11-23 19:39:27 -05:00
delete m_glContext ;
2014-10-27 20:05:40 -04:00
2015-01-10 21:49:58 -05:00
# ifdef __APPLE__
AudioThread : : deviceCleanup ( ) ;
# endif
2014-10-27 20:05:40 -04:00
return wxApp : : OnExit ( ) ;
}
PrimaryGLContext & CubicSDR : : GetContext ( wxGLCanvas * canvas ) {
PrimaryGLContext * glContext ;
if ( ! m_glContext ) {
2014-11-12 21:55:11 -05:00
m_glContext = new PrimaryGLContext ( canvas , NULL ) ;
2014-10-27 20:05:40 -04:00
}
glContext = m_glContext ;
return * glContext ;
}
2015-07-20 18:39:45 -04:00
void CubicSDR : : OnInitCmdLine ( wxCmdLineParser & parser ) {
parser . SetDesc ( commandLineInfo ) ;
parser . SetSwitchChars ( wxT ( " - " ) ) ;
}
bool CubicSDR : : OnCmdLineParsed ( wxCmdLineParser & parser ) {
wxString * confName = new wxString ;
if ( parser . Found ( " c " , confName ) ) {
if ( confName ) {
config . setConfigName ( confName - > ToStdString ( ) ) ;
}
}
config . load ( ) ;
2015-11-08 16:45:06 -05:00
# ifdef BUNDLE_SOAPY_MODS
2015-11-10 19:25:41 -05:00
if ( parser . Found ( " b " ) ) {
2015-11-08 16:45:06 -05:00
useLocalMod . store ( false ) ;
2015-11-10 19:25:41 -05:00
} else {
useLocalMod . store ( true ) ;
2015-11-08 16:45:06 -05:00
}
# else
2015-11-10 19:25:41 -05:00
useLocalMod . store ( true ) ;
2015-11-08 16:45:06 -05:00
# endif
2015-11-12 18:38:38 -05:00
wxString * modPath = new wxString ;
if ( parser . Found ( " m " , modPath ) ) {
if ( modPath ) {
modulePath = modPath - > ToStdString ( ) ;
} else {
modulePath = " " ;
}
}
2015-11-08 16:45:06 -05:00
2015-07-20 18:39:45 -04:00
return true ;
}
2015-11-12 18:38:38 -05:00
void CubicSDR : : closeDeviceSelector ( ) {
if ( deviceSelectorOpen ) {
deviceSelectorDialog - > Close ( ) ;
}
}
2015-10-04 16:07:14 -04:00
void CubicSDR : : deviceSelector ( ) {
2015-10-05 02:21:08 -04:00
if ( deviceSelectorOpen ) {
deviceSelectorDialog - > Raise ( ) ;
deviceSelectorDialog - > SetFocus ( ) ;
return ;
2015-10-03 21:35:11 -04:00
}
2015-10-05 19:59:17 -04:00
deviceSelectorOpen . store ( true ) ;
2015-10-05 02:21:08 -04:00
deviceSelectorDialog = new SDRDevicesDialog ( appframe ) ;
deviceSelectorDialog - > Show ( ) ;
}
void CubicSDR : : addRemote ( std : : string remoteAddr ) {
SDREnumerator : : addRemote ( remoteAddr ) ;
devicesReady . store ( false ) ;
t_SDREnum = new std : : thread ( & SDREnumerator : : threadMain , sdrEnum ) ;
}
void CubicSDR : : removeRemote ( std : : string remoteAddr ) {
SDREnumerator : : removeRemote ( remoteAddr ) ;
2015-10-03 21:35:11 -04:00
}
void CubicSDR : : sdrThreadNotify ( SDRThread : : SDRThreadState state , std : : string message ) {
2015-10-05 02:21:08 -04:00
notify_busy . lock ( ) ;
2015-11-03 21:06:22 -05:00
if ( state = = SDRThread : : SDR_THREAD_INITIALIZED ) {
appframe - > initDeviceParams ( getDevice ( ) ) ;
}
2015-10-05 02:21:08 -04:00
if ( state = = SDRThread : : SDR_THREAD_MESSAGE ) {
notifyMessage = message ;
}
2015-10-03 21:35:11 -04:00
if ( state = = SDRThread : : SDR_THREAD_TERMINATED ) {
t_SDR - > join ( ) ;
delete t_SDR ;
}
if ( state = = SDRThread : : SDR_THREAD_FAILED ) {
2015-10-05 02:21:08 -04:00
notifyMessage = message ;
// wxMessageDialog *info;
// info = new wxMessageDialog(NULL, message, wxT("Error initializing device"), wxOK | wxICON_ERROR);
// info->ShowModal();
2015-10-03 21:35:11 -04:00
}
2015-10-09 19:42:52 -04:00
//if (appframe) { appframe->SetStatusText(message); }
2015-10-05 02:21:08 -04:00
notify_busy . unlock ( ) ;
2015-10-03 21:35:11 -04:00
}
2015-10-04 16:07:14 -04:00
void CubicSDR : : sdrEnumThreadNotify ( SDREnumerator : : SDREnumState state , std : : string message ) {
2015-10-05 02:21:08 -04:00
notify_busy . lock ( ) ;
if ( state = = SDREnumerator : : SDR_ENUM_MESSAGE ) {
notifyMessage = message ;
}
2015-10-04 16:07:14 -04:00
if ( state = = SDREnumerator : : SDR_ENUM_DEVICES_READY ) {
2015-10-05 02:21:08 -04:00
devs = SDREnumerator : : enumerate_devices ( " " , true ) ;
devicesReady . store ( true ) ;
2015-10-04 16:07:14 -04:00
}
2015-10-09 19:42:52 -04:00
//if (appframe) { appframe->SetStatusText(message); }
2015-10-05 02:21:08 -04:00
notify_busy . unlock ( ) ;
2015-12-07 22:05:31 -05:00
if ( state = = SDREnumerator : : SDR_ENUM_FAILED ) {
wxMessageDialog * info ;
info = new wxMessageDialog ( NULL , wxT ( " \n No SoapySDR modules were found. \n \n CubicSDR requires at least one SoapySDR device support module to be installed. \n \n Please visit https://github.com/cjcliffe/CubicSDR/wiki and in the build instructions for your platform read the 'Support Modules' section for more information. " ) , wxT ( " \x28 \u256F \xB0 \u25A1 \xB0 \uFF09 \u256F \uFE35 \x20 \u253B \u2501 \u253B " ) , wxOK | wxICON_ERROR ) ;
info - > ShowModal ( ) ;
}
2015-10-04 16:07:14 -04:00
}
2015-01-04 17:11:20 -05:00
void CubicSDR : : setFrequency ( long long freq ) {
2015-01-11 17:08:16 -05:00
if ( freq < sampleRate / 2 ) {
freq = sampleRate / 2 ;
2015-01-04 13:20:31 -05:00
}
2014-11-23 19:39:27 -05:00
frequency = freq ;
2015-10-03 21:35:11 -04:00
sdrThread - > setFrequency ( freq ) ;
2015-12-31 21:28:56 -05:00
getSpectrumProcessor ( ) - > setPeakHold ( getSpectrumProcessor ( ) - > getPeakHold ( ) ) ;
2014-11-23 19:39:27 -05:00
}
2015-01-06 00:57:57 -05:00
long long CubicSDR : : getOffset ( ) {
return offset ;
}
void CubicSDR : : setOffset ( long long ofs ) {
offset = ofs ;
2015-10-03 21:35:11 -04:00
sdrThread - > setOffset ( offset ) ;
SDRDeviceInfo * dev = getDevice ( ) ;
2015-07-08 01:07:39 -04:00
config . getDevice ( dev - > getDeviceId ( ) ) - > setOffset ( ofs ) ;
2015-01-06 00:57:57 -05:00
}
2015-01-04 17:11:20 -05:00
long long CubicSDR : : getFrequency ( ) {
2014-11-23 19:39:27 -05:00
return frequency ;
2015-05-30 23:14:16 -04:00
}
2015-10-03 21:35:11 -04:00
void CubicSDR : : setSampleRate ( long long rate_in ) {
sampleRate = rate_in ;
sdrThread - > setSampleRate ( sampleRate ) ;
setFrequency ( frequency ) ;
2015-12-29 20:52:49 -05:00
2015-12-30 03:24:35 -05:00
if ( rate_in < = CHANNELIZER_RATE_MAX / 8 ) {
2015-12-29 23:44:00 -05:00
appframe - > setMainWaterfallFFTSize ( 512 ) ;
appframe - > getWaterfallDataThread ( ) - > getProcessor ( ) - > setHideDC ( false ) ;
spectrumVisualThread - > getProcessor ( ) - > setHideDC ( false ) ;
} else if ( rate_in < = CHANNELIZER_RATE_MAX ) {
2015-12-29 20:52:49 -05:00
appframe - > setMainWaterfallFFTSize ( 1024 ) ;
appframe - > getWaterfallDataThread ( ) - > getProcessor ( ) - > setHideDC ( false ) ;
spectrumVisualThread - > getProcessor ( ) - > setHideDC ( false ) ;
} else if ( rate_in > CHANNELIZER_RATE_MAX ) {
appframe - > setMainWaterfallFFTSize ( 2048 ) ;
appframe - > getWaterfallDataThread ( ) - > getProcessor ( ) - > setHideDC ( true ) ;
spectrumVisualThread - > getProcessor ( ) - > setHideDC ( true ) ;
}
2015-05-30 23:14:16 -04:00
}
2015-10-04 16:07:14 -04:00
void CubicSDR : : setDevice ( SDRDeviceInfo * dev ) {
if ( ! sdrThread - > isTerminated ( ) ) {
sdrThread - > terminate ( ) ;
if ( t_SDR ) {
t_SDR - > join ( ) ;
2015-10-04 19:55:52 -04:00
delete t_SDR ;
2015-10-04 16:07:14 -04:00
}
}
2015-10-03 21:35:11 -04:00
2015-11-04 02:04:52 -05:00
for ( SoapySDR : : Kwargs : : const_iterator i = settingArgs . begin ( ) ; i ! = settingArgs . end ( ) ; i + + ) {
sdrThread - > writeSetting ( i - > first , i - > second ) ;
}
sdrThread - > setStreamArgs ( streamArgs ) ;
2015-10-04 16:07:14 -04:00
sdrThread - > setDevice ( dev ) ;
DeviceConfig * devConfig = config . getDevice ( dev - > getDeviceId ( ) ) ;
2015-10-04 19:55:52 -04:00
SDRDeviceChannel * chan = dev - > getRxChannel ( ) ;
if ( chan ) {
long long freqHigh , freqLow ;
freqHigh = chan - > getRFRange ( ) . getHigh ( ) ;
freqLow = chan - > getRFRange ( ) . getLow ( ) ;
2015-10-05 02:21:08 -04:00
// upconverter settings don't like this, need to handle elsewhere..
// if (frequency > freqHigh) {
// frequency = freqHigh;
// }
// else if (frequency < freqLow) {
// frequency = freqLow;
// }
2015-10-04 19:55:52 -04:00
2015-10-20 23:57:54 -04:00
// Try for a reasonable default sample rate.
2015-10-21 16:56:32 -04:00
if ( ! sampleRateInitialized . load ( ) ) {
2015-10-20 23:57:54 -04:00
sampleRate = chan - > getSampleRateNear ( DEFAULT_SAMPLE_RATE ) ;
2015-10-21 16:56:32 -04:00
sampleRateInitialized . store ( true ) ;
2015-10-20 23:57:54 -04:00
}
2015-10-04 19:55:52 -04:00
int rateHigh , rateLow ;
2015-05-31 22:13:14 -04:00
2015-10-20 23:57:54 -04:00
rateHigh = rateLow = sampleRate ;
if ( chan - > getSampleRates ( ) . size ( ) ) {
rateLow = chan - > getSampleRates ( ) [ 0 ] ;
rateHigh = chan - > getSampleRates ( ) [ chan - > getSampleRates ( ) . size ( ) - 1 ] ;
}
2015-10-04 19:55:52 -04:00
if ( sampleRate > rateHigh ) {
sampleRate = rateHigh ;
} else if ( sampleRate < rateLow ) {
sampleRate = rateLow ;
}
if ( frequency < sampleRate / 2 ) {
frequency = sampleRate / 2 ;
}
setFrequency ( frequency ) ;
setSampleRate ( sampleRate ) ;
setPPM ( devConfig - > getPPM ( ) ) ;
setOffset ( devConfig - > getOffset ( ) ) ;
t_SDR = new std : : thread ( & SDRThread : : threadMain , sdrThread ) ;
}
2015-05-31 22:13:14 -04:00
}
2015-10-03 21:35:11 -04:00
SDRDeviceInfo * CubicSDR : : getDevice ( ) {
return sdrThread - > getDevice ( ) ;
2014-11-23 19:39:27 -05:00
}
2014-12-10 21:22:13 -05:00
2015-08-01 11:03:00 -04:00
ScopeVisualProcessor * CubicSDR : : getScopeProcessor ( ) {
return & scopeProcessor ;
}
2015-08-16 18:12:12 -04:00
SpectrumVisualProcessor * CubicSDR : : getSpectrumProcessor ( ) {
return spectrumVisualThread - > getProcessor ( ) ;
2015-08-03 01:38:38 -04:00
}
2015-08-16 18:12:12 -04:00
SpectrumVisualProcessor * CubicSDR : : getDemodSpectrumProcessor ( ) {
return demodVisualThread - > getProcessor ( ) ;
2015-08-11 00:50:43 -04:00
}
2014-12-10 21:22:13 -05:00
DemodulatorThreadOutputQueue * CubicSDR : : getAudioVisualQueue ( ) {
2015-07-30 20:36:06 -04:00
return pipeAudioVisualData ;
2014-12-10 21:22:13 -05:00
}
2014-12-26 16:15:35 -05:00
DemodulatorThreadInputQueue * CubicSDR : : getIQVisualQueue ( ) {
2015-07-30 20:36:06 -04:00
return pipeIQVisualData ;
2014-12-10 21:22:13 -05:00
}
2015-08-11 00:50:43 -04:00
DemodulatorThreadInputQueue * CubicSDR : : getWaterfallVisualQueue ( ) {
return pipeWaterfallIQVisualData ;
}
2014-12-10 21:22:13 -05:00
DemodulatorMgr & CubicSDR : : getDemodMgr ( ) {
return demodMgr ;
}
2015-10-18 12:26:07 -04:00
SDRPostThread * CubicSDR : : getSDRPostThread ( ) {
return sdrPostThread ;
}
2015-11-03 21:06:22 -05:00
SDRThread * CubicSDR : : getSDRThread ( ) {
return sdrThread ;
}
2014-12-10 21:22:13 -05:00
void CubicSDR : : bindDemodulator ( DemodulatorInstance * demod ) {
if ( ! demod ) {
return ;
}
sdrPostThread - > bindDemodulator ( demod ) ;
}
2015-01-11 17:08:16 -05:00
long long CubicSDR : : getSampleRate ( ) {
return sampleRate ;
}
2014-12-10 21:22:13 -05:00
void CubicSDR : : removeDemodulator ( DemodulatorInstance * demod ) {
if ( ! demod ) {
return ;
}
2015-01-22 23:41:33 -05:00
demod - > setActive ( false ) ;
2014-12-10 21:22:13 -05:00
sdrPostThread - > removeDemodulator ( demod ) ;
}
2015-01-12 00:40:43 -05:00
std : : vector < SDRDeviceInfo * > * CubicSDR : : getDevices ( ) {
2015-09-13 22:18:29 -04:00
return devs ;
2015-01-12 00:40:43 -05:00
}
2015-01-12 00:51:57 -05:00
2015-04-13 19:58:34 -04:00
AppConfig * CubicSDR : : getConfig ( ) {
return & config ;
}
2015-04-13 21:18:45 -04:00
2015-04-22 22:54:48 -04:00
void CubicSDR : : saveConfig ( ) {
config . save ( ) ;
}
2015-04-13 21:18:45 -04:00
void CubicSDR : : setPPM ( int ppm_in ) {
ppm = ppm_in ;
2015-10-03 21:35:11 -04:00
sdrThread - > setPPM ( ppm ) ;
2015-04-13 21:18:45 -04:00
2015-10-03 21:35:11 -04:00
SDRDeviceInfo * dev = getDevice ( ) ;
if ( dev ) {
config . getDevice ( dev - > getDeviceId ( ) ) - > setPPM ( ppm_in ) ;
}
2015-04-13 21:18:45 -04:00
}
int CubicSDR : : getPPM ( ) {
2015-10-03 21:35:11 -04:00
SDRDeviceInfo * dev = sdrThread - > getDevice ( ) ;
if ( dev ) {
ppm = config . getDevice ( dev - > getDeviceId ( ) ) - > getPPM ( ) ;
2015-04-13 21:18:45 -04:00
}
return ppm ;
}
2015-05-04 19:44:03 -04:00
2015-08-14 20:19:37 -04:00
void CubicSDR : : showFrequencyInput ( FrequencyDialog : : FrequencyDialogTarget targetMode ) {
const wxString demodTitle ( " Set Demodulator Frequency " ) ;
const wxString freqTitle ( " Set Center Frequency " ) ;
const wxString bwTitle ( " Set Demodulator Bandwidth " ) ;
wxString title ;
switch ( targetMode ) {
case FrequencyDialog : : FDIALOG_TARGET_DEFAULT :
title = demodMgr . getActiveDemodulator ( ) ? demodTitle : freqTitle ;
break ;
case FrequencyDialog : : FDIALOG_TARGET_BANDWIDTH :
title = bwTitle ;
break ;
default :
break ;
}
FrequencyDialog fdialog ( appframe , - 1 , title , demodMgr . getActiveDemodulator ( ) , wxPoint ( - 100 , - 100 ) , wxSize ( 320 , 75 ) , wxDEFAULT_DIALOG_STYLE , targetMode ) ;
2015-05-10 01:39:10 -04:00
fdialog . ShowModal ( ) ;
2015-05-04 19:44:03 -04:00
}
2015-05-10 01:39:10 -04:00
2015-09-08 21:32:15 -04:00
AppFrame * CubicSDR : : getAppFrame ( ) {
return appframe ;
}
2015-05-10 21:43:03 -04:00
void CubicSDR : : setFrequencySnap ( int snap ) {
if ( snap > 1000000 ) {
snap = 1000000 ;
}
this - > snap = snap ;
}
int CubicSDR : : getFrequencySnap ( ) {
return snap ;
}
2015-10-05 02:21:08 -04:00
bool CubicSDR : : areDevicesReady ( ) {
return devicesReady . load ( ) ;
}
bool CubicSDR : : areDevicesEnumerating ( ) {
return ! sdrEnum - > isTerminated ( ) ;
}
std : : string CubicSDR : : getNotification ( ) {
std : : string msg ;
notify_busy . lock ( ) ;
msg = notifyMessage ;
notify_busy . unlock ( ) ;
return msg ;
}
void CubicSDR : : setDeviceSelectorClosed ( ) {
deviceSelectorOpen . store ( false ) ;
}
2015-10-10 01:13:48 -04:00
bool CubicSDR : : isDeviceSelectorOpen ( ) {
return deviceSelectorOpen . load ( ) ;
}
2015-10-27 01:56:49 -04:00
void CubicSDR : : setAGCMode ( bool mode ) {
agcMode . store ( mode ) ;
sdrThread - > setAGCMode ( mode ) ;
}
bool CubicSDR : : getAGCMode ( ) {
return agcMode . load ( ) ;
}
void CubicSDR : : setGain ( std : : string name , float gain_in ) {
sdrThread - > setGain ( name , gain_in ) ;
}
float CubicSDR : : getGain ( std : : string name ) {
return sdrThread - > getGain ( name ) ;
}
2015-11-04 02:04:52 -05:00
void CubicSDR : : setStreamArgs ( SoapySDR : : Kwargs streamArgs_in ) {
streamArgs = streamArgs_in ;
}
void CubicSDR : : setDeviceArgs ( SoapySDR : : Kwargs settingArgs_in ) {
settingArgs = settingArgs_in ;
}
2015-11-08 16:45:06 -05:00
bool CubicSDR : : getUseLocalMod ( ) {
return useLocalMod . load ( ) ;
2015-11-12 18:38:38 -05:00
}
std : : string CubicSDR : : getModulePath ( ) {
return modulePath ;
}