void
NmeaReplayGlue::Start()
{
assert(parser == NULL);
assert(device == NULL);
parser = new NMEAParser();
parser->SetReal(false);
/* get the device driver name from the profile */
const DeviceConfig &config =
CommonInterface::GetSystemSettings().devices[0];
parser->SetIgnoreChecksum(config.ignore_checksum);
/* instantiate it */
const struct DeviceRegister *driver = FindDriverByName(config.driver_name);
assert(driver != NULL);
if (driver->CreateOnPort != NULL) {
DeviceConfig config;
config.Clear();
device = driver->CreateOnPort(config, port);
}
NmeaReplay::Start();
}
static bool
FinishDeviceFields(DeviceConfig &config,
WndProperty *port_field, WndProperty *speed_field,
WndProperty *driver_field)
{
bool changed = false;
if (port_field != NULL && FinishPortField(config, *port_field))
changed = true;
#ifndef ANDROID
if (config.UsesSpeed() && speed_field != NULL &&
(int)config.speed_index != speed_field->GetDataField()->GetAsInteger()) {
config.speed_index = speed_field->GetDataField()->GetAsInteger();
changed = true;
}
#endif
if (config.UsesDriver() && driver_field != NULL &&
!config.driver_name.equals(driver_field->GetDataField()->GetAsString())) {
config.driver_name = driver_field->GetDataField()->GetAsString();
changed = true;
}
return changed;
}
void SDRThread::setAGCMode(bool mode) {
agc_mode.store(mode);
agc_mode_changed.store(true);
DeviceConfig *devConfig = deviceConfig.load();
if (devConfig) {
devConfig->setAGCMode(mode);
}
}
DeviceConfig *AppConfig::getDevice(std::string deviceId) {
if (deviceConfig.find(deviceId) == deviceConfig.end()) {
deviceConfig[deviceId] = new DeviceConfig();
}
DeviceConfig *conf = deviceConfig[deviceId];
conf->setDeviceId(deviceId);
return conf;
}
/** Get the key bound to a player action (enum GUI::PlayerAction)*/
std::string getKeyBinding(int Enum_value)
{
InputDevice* device = input_manager->getDeviceManager()->getLatestUsedDevice();
DeviceConfig* config = device->getConfiguration();
PlayerAction ScriptAction = (PlayerAction)Enum_value;
irr::core::stringw control = config->getBindingAsString(ScriptAction);
std::string key = StringUtils::wideToUtf8(control);
return key;
}
void SDRThread::setSampleRate(int rate) {
sampleRate.store(rate);
rate_changed = true;
DeviceConfig *devConfig = deviceConfig.load();
if (devConfig) {
devConfig->setSampleRate(rate);
}
// std::cout << "Set sample rate: " << sampleRate.load() << std::endl;
}
void SDRDevicesDialog::OnUseSelected( wxMouseEvent& event ) {
if (dev != NULL) {
int i = 0;
SoapySDR::ArgInfoList::const_iterator args_i;
SoapySDR::ArgInfoList args = dev->getSettingsArgInfo();
SoapySDR::Kwargs settingArgs;
SoapySDR::Kwargs streamArgs;
for (args_i = args.begin(); args_i != args.end(); args_i++) {
SoapySDR::ArgInfo arg = (*args_i);
wxPGProperty *prop = props[i];
if (arg.type == SoapySDR::ArgInfo::STRING && arg.options.size()) {
settingArgs[arg.key] = arg.options[prop->GetChoiceSelection()];
} else if (arg.type == SoapySDR::ArgInfo::BOOL) {
settingArgs[arg.key] = (prop->GetValueAsString()=="True")?"true":"false";
} else {
settingArgs[arg.key] = prop->GetValueAsString();
}
i++;
}
if (dev->getRxChannel()) {
args = dev->getRxChannel()->getStreamArgsInfo();
if (args.size()) {
for (args_i = args.begin(); args_i != args.end(); args_i++) {
SoapySDR::ArgInfo arg = (*args_i);
wxPGProperty *prop = props[i];
if (arg.type == SoapySDR::ArgInfo::STRING && arg.options.size()) {
streamArgs[arg.key] = arg.options[prop->GetChoiceSelection()];
} else if (arg.type == SoapySDR::ArgInfo::BOOL) {
streamArgs[arg.key] = (prop->GetValueAsString()=="True")?"true":"false";
} else {
streamArgs[arg.key] = prop->GetValueAsString();
}
i++;
}
}
}
AppConfig *cfg = wxGetApp().getConfig();
DeviceConfig *devConfig = cfg->getDevice(dev->getDeviceId());
devConfig->setSettings(settingArgs);
devConfig->setStreamOpts(streamArgs);
wxGetApp().setDeviceArgs(settingArgs);
wxGetApp().setStreamArgs(streamArgs);
wxGetApp().setDevice(dev);
Close();
}
}
void CubicSDR::setDevice(SDRDeviceInfo *dev) {
if (!sdrThread->isTerminated()) {
sdrThread->terminate();
if (t_SDR) {
t_SDR->join();
delete t_SDR;
}
}
for (SoapySDR::Kwargs::const_iterator i = settingArgs.begin(); i != settingArgs.end(); i++) {
sdrThread->writeSetting(i->first, i->second);
}
sdrThread->setStreamArgs(streamArgs);
sdrThread->setDevice(dev);
DeviceConfig *devConfig = config.getDevice(dev->getDeviceId());
SoapySDR::Device *soapyDev = dev->getSoapyDevice();
if (soapyDev) {
if (long devSampleRate = devConfig->getSampleRate()) {
sampleRate = dev->getSampleRateNear(SOAPY_SDR_RX, 0, devSampleRate);
sampleRateInitialized.store(true);
}
if (!sampleRateInitialized.load()) {
sampleRate = dev->getSampleRateNear(SOAPY_SDR_RX, 0, DEFAULT_SAMPLE_RATE);
sampleRateInitialized.store(true);
} else {
sampleRate = dev->getSampleRateNear(SOAPY_SDR_RX, 0, sampleRate);
}
if (frequency < sampleRate/2) {
frequency = sampleRate/2;
}
setFrequency(frequency);
setSampleRate(sampleRate);
setPPM(devConfig->getPPM());
setOffset(devConfig->getOffset());
if (devConfig->getAGCMode()) {
setAGCMode(true);
} else {
setAGCMode(false);
}
t_SDR = new std::thread(&SDRThread::threadMain, sdrThread);
}
stoppedDev = nullptr;
}
void SDRThread::setGain(std::string name, float value) {
std::lock_guard < std::mutex > lock(gain_busy);
gainValues[name] = value;
gainChanged[name] = true;
gain_value_changed.store(true);
DeviceConfig *devConfig = deviceConfig.load();
if (devConfig) {
devConfig->setGain(name, value);
}
}
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();
}
}
Matrix4CalibrationDev::Matrix4CalibrationDev(const DeviceConfig & deviceConfig) :
senderThreadActive(false),
receiverThreadActive(false),
vec1Size(0),
vec2Size(0),
trackVectors(false),
premultiply(false),
useAverage(false) {
this->deviceDescriptor.setEntityID(deviceConfig.getEntityID());
this->entityID = this->deviceDescriptor.getEntityID();
map<string, Port> portMap;
map<string, int> namePortNrMap;
addPort(Port("Vector1", "Vector4", Port::Sink, ""), PortNR_Vector1, portMap, namePortNrMap);
addPort(Port("Vector2", "Vector4", Port::Sink, ""), PortNR_Vector2, portMap, namePortNrMap);
addPort(Port("CalibratedMatrix", "Matrix4", Port::Source, ""), PortNR_CalibratedMatrix, portMap, namePortNrMap);
addPort(Port("ApplyVectors", "DigitalChannel", Port::Sink, ""), PortNR_ApplyVectors, portMap, namePortNrMap);
addPort(Port("ClearVectors", "DigitalChannel", Port::Sink, ""), PortNR_ClearVectors, portMap, namePortNrMap);
addPort(Port("LoadCalibratedMatrix", "DigitalChannel", Port::Sink, ""), PortNR_LoadCalibratedMatrix, portMap, namePortNrMap);
addPort(Port("SaveCalibratedMatrix", "DigitalChannel", Port::Sink, ""), PortNR_SaveCalibratedMatrix, portMap, namePortNrMap);
addPort(Port("SendCalibratedMatrix", "DigitalChannel", Port::Sink, ""), PortNR_SendCalibratedMatrix, portMap, namePortNrMap);
addPort(Port("CalcCalibratedMatrix", "DigitalChannel", Port::Sink, ""), PortNR_CalcCalibratedMatrix, portMap, namePortNrMap);
DeviceType deviceType;
deviceType.setPortMap(portMap);
deviceType.setDeviceTypeName("Matrix4CalibrationDev");
deviceType.setDescription("");
this->deviceDescriptor.setDeviceType(deviceType);
this->deviceDescriptor.setNameChannelNrMap(namePortNrMap);
try {
this->initialSend = deviceConfig.getParameterGroup().getInt("CalibratedMatrix|InitialSend") != 0;
TFDEBUG("initialSend = " << this->initialSend);
this->calibratedMatrixPath = deviceConfig.getParameterGroup().getString("CalibratedMatrix|Path");
TFDEBUG("calibratedMatrixPath = " << this->calibratedMatrixPath);
this->premultiply = deviceConfig.getParameterGroup().getInt("CalibratedMatrix|Pre-multiply") != 0;
TFINFO("pre-multiply = " << this->premultiply);
this->useAverage = deviceConfig.getParameterGroup().getInt("ApplyVectors|useAverage") != 0;
TFINFO("useAverage = " << this->useAverage);
}
catch(Exception & e) {
TFERROR(e.getFormattedString());
}
}
void CubicSDR::setDevice(int deviceId) {
sdrThread->setDeviceId(deviceId);
SDRThreadCommand command(SDRThreadCommand::SDR_THREAD_CMD_SET_DEVICE);
command.llong_value = deviceId;
pipeSDRCommand->push(command);
SDRDeviceInfo *dev = (*getDevices())[deviceId];
DeviceConfig *devConfig = config.getDevice(dev->getDeviceId());
setPPM(devConfig->getPPM());
setDirectSampling(devConfig->getDirectSampling());
setSwapIQ(devConfig->getIQSwap());
setOffset(devConfig->getOffset());
}
void
devStartup()
{
LogStartUp(_T("Register serial devices"));
const SystemSettings &settings = CommonInterface::GetSystemSettings();
bool none_available = true;
for (unsigned i = 0; i < NUMDEV; ++i) {
DeviceDescriptor &device = *device_list[i];
const DeviceConfig &config = settings.devices[i];
if (!config.IsAvailable()) {
device.ClearConfig();
continue;
}
none_available = false;
bool overlap = false;
for (unsigned j = 0; j < i; ++j)
if (DeviceConfigOverlaps(config, device_list[j]->GetConfig()))
overlap = true;
if (overlap) {
device.ClearConfig();
continue;
}
device.SetConfig(config);
devInitOne(*device_list[i]);
}
if (none_available) {
#ifdef ANDROID
/* fall back to built-in GPS when no configured device is
available on this platform */
LogStartUp(_T("Falling back to built-in GPS"));
DeviceConfig config;
config.Clear();
config.port_type = DeviceConfig::PortType::INTERNAL;
DeviceDescriptor &device = *device_list[0];
device.SetConfig(config);
devInitOne(device);
#endif
}
}
void CubicSDR::setDevice(SDRDeviceInfo *dev) {
if (!sdrThread->isTerminated()) {
sdrThread->terminate();
if (t_SDR) {
t_SDR->join();
delete t_SDR;
}
}
for (SoapySDR::Kwargs::const_iterator i = settingArgs.begin(); i != settingArgs.end(); i++) {
sdrThread->writeSetting(i->first, i->second);
}
sdrThread->setStreamArgs(streamArgs);
sdrThread->setDevice(dev);
DeviceConfig *devConfig = config.getDevice(dev->getDeviceId());
SoapySDR::Device *soapyDev = dev->getSoapyDevice();
if (soapyDev) {
//long long freqHigh, freqLow;
//SoapySDR::RangeList freqRange = soapyDev->getFrequencyRange(SOAPY_SDR_RX, 0);
//freqLow = freqRange[0].minimum();
//freqHigh = freqRange[freqRange.size()-1].maximum();
// Try for a reasonable default sample rate.
if (!sampleRateInitialized.load()) {
sampleRate = dev->getSampleRateNear(SOAPY_SDR_RX, 0, DEFAULT_SAMPLE_RATE);
sampleRateInitialized.store(true);
} else {
sampleRate = dev->getSampleRateNear(SOAPY_SDR_RX, 0, sampleRate);
}
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);
}
}
int main(int argc, char **argv)
{
NarrowString<1024> usage;
usage = "DRIVER\n\n"
"Where DRIVER is one of:";
{
const DeviceRegister *driver;
for (unsigned i = 0; (driver = GetDriverByIndex(i)) != nullptr; ++i) {
WideToUTF8Converter driver_name(driver->name);
usage.AppendFormat("\n\t%s", (const char *)driver_name);
}
}
Args args(argc, argv, usage);
tstring driver_name = args.ExpectNextT();
args.ExpectEnd();
driver = FindDriverByName(driver_name.c_str());
if (driver == nullptr) {
_ftprintf(stderr, _T("No such driver: %s\n"), driver_name.c_str());
return 1;
}
DeviceConfig config;
config.Clear();
NullPort port;
Device *device = driver->CreateOnPort != nullptr
? driver->CreateOnPort(config, port)
: nullptr;
NMEAParser parser;
NMEAInfo data;
data.Reset();
char buffer[1024];
while (fgets(buffer, sizeof(buffer), stdin) != nullptr) {
StripRight(buffer);
if (device == nullptr || !device->ParseNMEA(buffer, data))
parser.ParseLine(buffer, data);
}
Dump(data);
return EXIT_SUCCESS;
}
HapticDev::HapticDev(const DeviceConfig & deviceConfig)
: udpReceiverSocket(inSerializedDataQueue) {
this->deviceDescriptor.setEntityID(deviceConfig.getEntityID());
this->entityID = this->deviceDescriptor.getEntityID();
map<string, Port> portMap;
portMap["HOUT1"] = Port("HOUT1", "HapticChannel", Port::Source);
DeviceType deviceType;
deviceType.setPortMap(portMap);
deviceType.setDeviceTypeName(getDeviceName());
deviceType.setDescription("HapticDevice");
this->deviceDescriptor.setDeviceType(deviceType);
std::map<std::string, int> nameChannelNrMap;
int nr = 0;
for (std::map<string, Port>::const_iterator i = portMap.begin(),
e = portMap.end(); i != e; ++nr, ++i)
nameChannelNrMap[(*i).second.getName()] = nr;
this->deviceDescriptor.setNameChannelNrMap(nameChannelNrMap);
}
DummyDevPackedVector4::DummyDevPackedVector4(const DeviceConfig & deviceConfig) {
this->deviceDescriptor.setEntityID(deviceConfig.getEntityID());
this->entityID = this->deviceDescriptor.getEntityID();
map<string, Port> portMap;
portMap["pv1"] = Port("pv1", "PackedVector4", Port::Source, "");
DeviceType deviceType;
deviceType.setPortMap(portMap);
deviceType.setDeviceTypeName("DummyDevPackedVector4");
deviceType.setDescription("");
this->deviceDescriptor.setDeviceType(deviceType);
std::map<std::string, int> nameChannelNrMap;
int nr = 1;
map<string, Port>::iterator i = portMap.begin();
map<string, Port>::iterator e = portMap.end();
while (i != e) {
nameChannelNrMap[(*i).second.getName()] = nr;
++nr;
++i;
}
this->deviceDescriptor.setNameChannelNrMap(nameChannelNrMap);
}
void Set(const DeviceConfig &config, const DeviceDescriptor &device,
const NMEAInfo &basic) {
/* if a DeviceDescriptor is "unconfigured" but its DeviceConfig
contains a valid configuration, then it got disabled by
DeviceConfigOverlaps(), i.e. it's duplicate */
duplicate = !config.IsDisabled() && !device.IsConfigured();
switch (device.GetState()) {
case PortState::READY:
open = true;
error = false;
break;
case PortState::FAILED:
open = false;
error = true;
break;
case PortState::LIMBO:
open = false;
error = false;
break;
}
alive = basic.alive;
location = basic.location_available;
gps = basic.gps.fix_quality_available;
baro = basic.baro_altitude_available ||
basic.pressure_altitude_available ||
basic.static_pressure_available;
airspeed = basic.airspeed_available;
vario = basic.total_energy_vario_available;
traffic = basic.flarm.IsDetected();
debug = device.IsDumpEnabled();
}
NmeaReplay::NmeaReplay(NLineReader *_reader, const DeviceConfig &config)
:reader(_reader),
parser(new NMEAParser()),
device(NULL)
{
parser->SetReal(false);
parser->SetIgnoreChecksum(config.ignore_checksum);
const struct DeviceRegister *driver = FindDriverByName(config.driver_name);
assert(driver != NULL);
if (driver->CreateOnPort != NULL) {
DeviceConfig config;
config.Clear();
device = driver->CreateOnPort(config, port);
}
clock.Reset();
}
DummyDevDA::DummyDevDA(const DeviceConfig & deviceConfig) {
this->deviceDescriptor.setEntityID(deviceConfig.getEntityID());
this->entityID = this->deviceDescriptor.getEntityID();
//cout << "===> DummyDevDA: " << this->entityID << endl;
map<string, Port> portMap;
portMap["DO1"] = Port("DO1", "DigitalChannel", Port::Source);
portMap["DO2"] = Port("DO2", "DigitalChannel", Port::Source);
portMap["DO3"] = Port("DO3", "DigitalChannel", Port::Source);
portMap["DO4"] = Port("DO4", "DigitalChannel", Port::Source);
portMap["DI1"] = Port("DI1", "DigitalChannel", Port::Sink);
portMap["DI2"] = Port("DI2", "DigitalChannel", Port::Sink);
portMap["DI3"] = Port("DI3", "DigitalChannel", Port::Sink);
portMap["DI4"] = Port("DI4", "DigitalChannel", Port::Sink);
portMap["DIO1"] = Port("DIO1", "DigitalChannel", Port::SourceAndSink);
portMap["DIO2"] = Port("DIO2", "DigitalChannel", Port::SourceAndSink);
portMap["DIO3"] = Port("DIO3", "DigitalChannel", Port::SourceAndSink);
portMap["DIO4"] = Port("DIO4", "DigitalChannel", Port::SourceAndSink);
portMap["AO1"] = Port("AO1", "AnalogChannel", Port::Source);
portMap["AO2"] = Port("AO2", "AnalogChannel", Port::Source);
portMap["AO3"] = Port("AO3", "AnalogChannel", Port::Source);
portMap["AO4"] = Port("AO4", "AnalogChannel", Port::Source);
portMap["AI1"] = Port("AI1", "AnalogChannel", Port::Sink);
portMap["AI2"] = Port("AI2", "AnalogChannel", Port::Sink);
portMap["AI3"] = Port("AI3", "AnalogChannel", Port::Sink);
portMap["AI4"] = Port("AI4", "AnalogChannel", Port::Sink);
portMap["AIO1"] = Port("AIO1", "AnalogChannel", Port::SourceAndSink);
portMap["AIO2"] = Port("AIO2", "AnalogChannel", Port::SourceAndSink);
portMap["AIO3"] = Port("AIO3", "AnalogChannel", Port::SourceAndSink);
portMap["AIO4"] = Port("AIO4", "AnalogChannel", Port::SourceAndSink);
DeviceType deviceType;
deviceType.setPortMap(portMap);
deviceType.setDeviceTypeName(getDeviceName());
deviceType.setDescription("Digital and Analog IO");
this->deviceDescriptor.setDeviceType(deviceType);
std::map<std::string, int> nameChannelNrMap;
int nr = 1;
map<string, Port>::iterator i = portMap.begin();
map<string, Port>::iterator e = portMap.end();
while (i != e) {
nameChannelNrMap[(*i).second.getName()] = nr;
++nr;
++i;
}
this->deviceDescriptor.setNameChannelNrMap(nameChannelNrMap);
}
void SDRDevicesDialog::OnPropGridChanged( wxPropertyGridEvent& event ) {
if (!editId) {
return;
}
SDRDeviceInfo *dev = getSelectedDevice(editId);
if (editId && event.GetProperty() == devSettings["name"]) {
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
wxString devName = event.GetPropertyValue().GetString();
devConfig->setDeviceName(devName.ToStdString());
if (editId) {
devTree->SetItemText(editId, devConfig->getDeviceName());
}
if (devName == "") {
event.GetProperty()->SetValueFromString(devConfig->getDeviceName());
}
}
if (dev && event.GetProperty() == devSettings["offset"]) {
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
long offset = event.GetPropertyValue().GetInteger();
devConfig->setOffset(offset);
}
}
void
NmeaReplayGlue::Start()
{
assert(parser == NULL);
assert(device == NULL);
parser = new NMEAParser();
parser->SetReal(false);
/* get the device driver name from the profile */
DeviceConfig config;
Profile::GetDeviceConfig(0, config);
/* instantiate it */
const struct DeviceRegister *driver = FindDriverByName(config.driver_name);
assert(driver != NULL);
if (driver->CreateOnPort != NULL) {
DeviceConfig config;
config.Clear();
device = driver->CreateOnPort(config, &port);
}
NmeaReplay::Start();
}
void GainCanvas::updateGainUI() {
SDRDeviceInfo *devInfo = wxGetApp().getDevice();
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(devInfo->getDeviceId());
gains = devInfo->getGains(SOAPY_SDR_RX, 0);
SDRRangeMap::iterator gi;
numGains = gains.size();
float i = 0;
if (!numGains) {
return;
}
spacing = 2.0/numGains;
barWidth = (1.0/numGains)*0.7;
startPos = spacing/2.0;
barHeight = 1.0f;
while (gainPanels.size()) {
MeterPanel *mDel = gainPanels.back();
gainPanels.pop_back();
bgPanel.removeChild(mDel);
delete mDel;
}
for (auto gi : gains) {
MeterPanel *mPanel = new MeterPanel(gi.first, gi.second.minimum(), gi.second.maximum(), devConfig->getGain(gi.first,wxGetApp().getGain(gi.first)));
float midPos = -1.0+startPos+spacing*i;
mPanel->setPosition(midPos, 0);
mPanel->setSize(barWidth, barHeight);
bgPanel.addChild(mPanel);
gainPanels.push_back(mPanel);
i++;
}
setThemeColors();
}
void SDRDevicesDialog::OnPropGridChanged( wxPropertyGridEvent& event ) {
if (editId && event.GetProperty() == devSettings["name"]) {
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
wxString devName = event.GetPropertyValue().GetString();
devConfig->setDeviceName(devName.ToStdString());
if (editId) {
devTree->SetItemText(editId, devConfig->getDeviceName());
}
if (devName == "") {
event.GetProperty()->SetValueFromString(devConfig->getDeviceName());
}
} else if (dev && event.GetProperty() == devSettings["offset"]) {
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
long offset = event.GetPropertyValue().GetInteger();
devConfig->setOffset(offset);
} else if (editId && dev) {
wxPGProperty *prop = event.GetProperty();
for (std::map<std::string, wxPGProperty *>::iterator rtp = runtimeProps.begin(); rtp != runtimeProps.end(); rtp++) {
if (rtp->second == prop) {
SoapySDR::Device *soapyDev = dev->getSoapyDevice();
std::string settingValue = prop->GetValueAsString().ToStdString();
SoapySDR::ArgInfo arg = runtimeArgs[rtp->first];
if (arg.type == SoapySDR::ArgInfo::STRING && arg.options.size()) {
settingValue = arg.options[prop->GetChoiceSelection()];
} else if (arg.type == SoapySDR::ArgInfo::BOOL) {
settingValue = (prop->GetValueAsString()=="True")?"true":"false";
} else {
settingValue = prop->GetValueAsString();
}
soapyDev->writeSetting(rtp->first, settingValue);
if (dev->isActive()) {
wxGetApp().getSDRThread()->writeSetting(rtp->first, settingValue);
}
refreshDeviceProperties();
return;
}
}
}
}
void SDRThread::init() {
//#warning Debug On
// SoapySDR_setLogLevel(SOAPY_SDR_DEBUG);
SDRDeviceInfo *devInfo = deviceInfo.load();
deviceConfig.store(wxGetApp().getConfig()->getDevice(devInfo->getDeviceId()));
DeviceConfig *devConfig = deviceConfig.load();
ppm.store(devConfig->getPPM());
ppm_changed.store(true);
std::string driverName = devInfo->getDriver();
offset = devConfig->getOffset();
SoapySDR::Kwargs args = devInfo->getDeviceArgs();
wxGetApp().sdrEnumThreadNotify(SDREnumerator::SDR_ENUM_MESSAGE, std::string("Initializing device."));
device = devInfo->getSoapyDevice();
SoapySDR::Kwargs currentStreamArgs = combineArgs(devInfo->getStreamArgs(),streamArgs);
stream = device->setupStream(SOAPY_SDR_RX,"CF32", std::vector<size_t>(), currentStreamArgs);
int streamMTU = device->getStreamMTU(stream);
mtuElems.store(streamMTU);
std::cout << "Stream MTU: " << mtuElems.load() << std::endl << std::flush;
deviceInfo.load()->setStreamArgs(currentStreamArgs);
deviceConfig.load()->setStreamOpts(currentStreamArgs);
wxGetApp().sdrEnumThreadNotify(SDREnumerator::SDR_ENUM_MESSAGE, std::string("Activating stream."));
device->setSampleRate(SOAPY_SDR_RX,0,sampleRate.load());
device->setFrequency(SOAPY_SDR_RX,0,"RF",frequency - offset.load());
device->activateStream(stream);
if (devInfo->hasCORR(SOAPY_SDR_RX, 0)) {
hasPPM.store(true);
device->setFrequency(SOAPY_SDR_RX,0,"CORR",ppm.load());
} else {
hasPPM.store(false);
}
if (device->hasDCOffsetMode(SOAPY_SDR_RX, 0)) {
hasHardwareDC.store(true);
// wxGetApp().sdrEnumThreadNotify(SDREnumerator::SDR_ENUM_MESSAGE, std::string("Found hardware DC offset correction support, internal disabled."));
device->setDCOffsetMode(SOAPY_SDR_RX, 0, true);
} else {
hasHardwareDC.store(false);
}
device->setGainMode(SOAPY_SDR_RX,0,agc_mode.load());
numChannels.store(getOptimalChannelCount(sampleRate.load()));
numElems.store(getOptimalElementCount(sampleRate.load(), 30));
if (!mtuElems.load()) {
mtuElems.store(numElems.load());
}
inpBuffer.data.resize(numElems.load());
overflowBuffer.data.resize(mtuElems.load());
buffs[0] = malloc(mtuElems.load() * 4 * sizeof(float));
numOverflow = 0;
SoapySDR::ArgInfoList settingsInfo = device->getSettingInfo();
SoapySDR::ArgInfoList::const_iterator settings_i;
if (!setting_value_changed.load()) {
settings.erase(settings.begin(), settings.end());
settingChanged.erase(settingChanged.begin(), settingChanged.end());
}
{ //enter scoped-lock
std::lock_guard < std::mutex > lock(setting_busy);
for (settings_i = settingsInfo.begin(); settings_i != settingsInfo.end(); settings_i++) {
SoapySDR::ArgInfo setting = (*settings_i);
if ((settingChanged.find(setting.key) != settingChanged.end()) && (settings.find(setting.key) != settings.end())) {
device->writeSetting(setting.key, settings[setting.key]);
settingChanged[setting.key] = false;
} else {
settings[setting.key] = device->readSetting(setting.key);
settingChanged[setting.key] = false;
}
}
setting_value_changed.store(false);
} //leave lock guard scope
updateSettings();
wxGetApp().sdrThreadNotify(SDRThread::SDR_THREAD_INITIALIZED, std::string("Device Initialized."));
}
void SDRDevicesDialog::OnDeviceTimer( wxTimerEvent& event ) {
if (refresh) {
if (wxGetApp().areModulesMissing()) {
if (!failed) {
wxMessageDialog *info;
info = new wxMessageDialog(NULL, wxT("\nNo SoapySDR modules were found.\n\nCubicSDR requires at least one SoapySDR device support module to be installed.\n\nPlease 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();
failed = true;
}
return;
}
if (wxGetApp().areDevicesEnumerating() || !wxGetApp().areDevicesReady()) {
std::string msg = wxGetApp().getNotification();
devStatusBar->SetStatusText(msg);
devTree->DeleteAllItems();
devTree->AddRoot(msg);
event.Skip();
return;
}
devTree->DeleteAllItems();
wxTreeItemId devRoot = devTree->AddRoot("Devices");
wxTreeItemId localBranch = devTree->AppendItem(devRoot, "Local");
wxTreeItemId dsBranch = devTree->AppendItem(devRoot, "Local Net");
wxTreeItemId remoteBranch = devTree->AppendItem(devRoot, "Remote");
wxTreeItemId manualBranch = devTree->AppendItem(devRoot, "Manual");
devs[""] = SDREnumerator::enumerate_devices("",true);
if (devs[""] != NULL) {
for (devs_i = devs[""]->begin(); devs_i != devs[""]->end(); devs_i++) {
DeviceConfig *devConfig = nullptr;
if ((*devs_i)->isManual()) {
std::string devName = "Unknown";
if ((*devs_i)->isAvailable()) {
devConfig = wxGetApp().getConfig()->getDevice((*devs_i)->getDeviceId());
devName = devConfig->getDeviceName();
} else {
devName = (*devs_i)->getDeviceId();
}
devItems[devTree->AppendItem(manualBranch, devName)] = (*devs_i);
} else if ((*devs_i)->isRemote()) {
devConfig = wxGetApp().getConfig()->getDevice((*devs_i)->getDeviceId());
devItems[devTree->AppendItem(dsBranch, devConfig->getDeviceName())] = (*devs_i);
} else {
devConfig = wxGetApp().getConfig()->getDevice((*devs_i)->getDeviceId());
devItems[devTree->AppendItem(localBranch, devConfig->getDeviceName())] = (*devs_i);
}
}
}
std::vector<std::string> remotes = SDREnumerator::getRemotes();
std::vector<SDRDeviceInfo *>::iterator remoteDevs_i;
if (remotes.size()) {
for (std::string remote : remotes) {
devs[remote] = SDREnumerator::enumerate_devices(remote, true);
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(remote);
wxTreeItemId remoteNode = devTree->AppendItem(remoteBranch, devConfig->getDeviceName());
if (devs[remote] != NULL) {
for (remoteDevs_i = devs[remote]->begin(); remoteDevs_i != devs[remote]->end(); remoteDevs_i++) {
devItems[devTree->AppendItem(remoteNode, (*remoteDevs_i)->getName())] = (*remoteDevs_i);
}
}
}
}
m_refreshButton->Enable();
m_addRemoteButton->Enable();
m_useSelectedButton->Enable();
devTree->Enable();
devTree->ExpandAll();
devStatusBar->SetStatusText("Ready.");
refresh = false;
}
}
void SDRDevicesDialog::OnPropGridChanged( wxPropertyGridEvent& event ) {
if (editId && event.GetProperty() == devSettings["name"]) {
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
wxString devName = event.GetPropertyValue().GetString();
devConfig->setDeviceName(devName.ToStdString());
if (editId) {
devTree->SetItemText(editId, devConfig->getDeviceName());
}
if (devName == "") {
event.GetProperty()->SetValueFromString(devConfig->getDeviceName());
}
} else if (dev && event.GetProperty() == devSettings["offset"]) {
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
long offset = event.GetPropertyValue().GetInteger();
devConfig->setOffset(offset);
if (dev->isActive() || !wxGetApp().getDevice()) {
wxGetApp().setOffset(offset);
}
}
else if (dev && event.GetProperty() == devSettings["sample_rate"]) {
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
std::string strRate = deviceArgs["sample_rate"].options[event.GetPropertyValue().GetInteger()];
long srate = 0;
try {
srate = std::stol(strRate);
devConfig->setSampleRate(srate);
if (dev->isActive() || !wxGetApp().getDevice()) {
wxGetApp().setSampleRate(srate);
}
} catch (std::invalid_argument e) {
// nop
}
} else if (dev && event.GetProperty() == devSettings["antenna"]) {
DeviceConfig *devConfig = wxGetApp().getConfig()->getDevice(dev->getDeviceId());
std::string strAntennaName = deviceArgs["antenna"].options[event.GetPropertyValue().GetInteger()];
try {
devConfig->setAntennaName(strAntennaName);
if (dev->isActive() || !wxGetApp().getDevice()) {
wxGetApp().setAntennaName(strAntennaName);
}
}
catch (std::invalid_argument e) {
// nop
}
}
else if (editId && dev) {
wxPGProperty *prop = event.GetProperty();
//change value of RuntimeProps
for (std::map<std::string, wxPGProperty *>::iterator rtp = runtimeProps.begin(); rtp != runtimeProps.end(); rtp++) {
if (rtp->second == prop) {
SoapySDR::Device *soapyDev = dev->getSoapyDevice();
std::string settingValue = prop->GetValueAsString().ToStdString();
SoapySDR::ArgInfo arg = runtimeArgs[rtp->first];
if (arg.type == SoapySDR::ArgInfo::STRING && arg.options.size()) {
settingValue = arg.options[prop->GetChoiceSelection()];
} else if (arg.type == SoapySDR::ArgInfo::BOOL) {
settingValue = (prop->GetValueAsString()=="True")?"true":"false";
} else {
settingValue = prop->GetValueAsString();
}
soapyDev->writeSetting(rtp->first, settingValue);
if (dev->isActive()) {
wxGetApp().getSDRThread()->writeSetting(rtp->first, settingValue);
}
wxGetApp().notifyMainUIOfDeviceChange();
return;
}
}
}
// general refresh.
wxGetApp().notifyMainUIOfDeviceChange();
}
void SDRThread::updateSettings() {
bool doUpdate = false;
if (offset_changed.load()) {
if (!freq_changed.load()) {
frequency.store(frequency.load());
freq_changed.store(true);
}
offset_changed.store(false);
}
if (rate_changed.load()) {
device->setSampleRate(SOAPY_SDR_RX,0,sampleRate.load());
sampleRate.store(device->getSampleRate(SOAPY_SDR_RX,0));
numChannels.store(getOptimalChannelCount(sampleRate.load()));
numElems.store(getOptimalElementCount(sampleRate.load(), 60));
int streamMTU = device->getStreamMTU(stream);
mtuElems.store(streamMTU);
if (!mtuElems.load()) {
mtuElems.store(numElems.load());
}
inpBuffer.data.resize(numElems.load());
overflowBuffer.data.resize(mtuElems.load());
free(buffs[0]);
buffs[0] = malloc(mtuElems.load() * 4 * sizeof(float));
numOverflow = 0;
rate_changed.store(false);
doUpdate = true;
}
if (ppm_changed.load() && hasPPM.load()) {
device->setFrequency(SOAPY_SDR_RX,0,"CORR",ppm.load());
ppm_changed.store(false);
}
if (freq_changed.load()) {
if (frequency_locked.load() && !frequency_lock_init.load()) {
device->setFrequency(SOAPY_SDR_RX,0,"RF",lock_freq.load());
frequency_lock_init.store(true);
} else if (!frequency_locked.load()) {
device->setFrequency(SOAPY_SDR_RX,0,"RF",frequency.load() - offset.load());
}
freq_changed.store(false);
}
// double devFreq = device->getFrequency(SOAPY_SDR_RX,0);
// if (((long long)devFreq + offset.load()) != frequency.load()) {
// wxGetApp().setFrequency((long long)devFreq + offset.load());
// }
if (agc_mode_changed.load()) {
device->setGainMode(SOAPY_SDR_RX, 0, agc_mode.load());
agc_mode_changed.store(false);
if (!agc_mode.load()) {
updateGains();
DeviceConfig *devConfig = deviceConfig.load();
ConfigGains gains = devConfig->getGains();
if (gains.size()) {
for (ConfigGains::iterator gain_i = gains.begin(); gain_i != gains.end(); gain_i++) {
setGain(gain_i->first, gain_i->second);
}
}
}
doUpdate = true;
}
if (gain_value_changed.load() && !agc_mode.load()) {
std::lock_guard < std::mutex > lock(gain_busy);
for (std::map<std::string,bool>::iterator gci = gainChanged.begin(); gci != gainChanged.end(); gci++) {
if (gci->second) {
device->setGain(SOAPY_SDR_RX, 0, gci->first, gainValues[gci->first]);
gainChanged[gci->first] = false;
}
}
gain_value_changed.store(false);
}
if (setting_value_changed.load()) {
std::lock_guard < std::mutex > lock(setting_busy);
for (std::map<std::string, bool>::iterator sci = settingChanged.begin(); sci != settingChanged.end(); sci++) {
if (sci->second) {
device->writeSetting(sci->first, settings[sci->first]);
settingChanged[sci->first] = false;
}
}
setting_value_changed.store(false);
doUpdate = true;
}
if (doUpdate) {
wxGetApp().sdrThreadNotify(SDRThread::SDR_THREAD_INITIALIZED, std::string("Settings updated."));
}
}
static void
SetupDeviceFields(const DeviceConfig &config,
WndProperty *port_field, WndProperty *speed_field,
WndProperty *driver_field, WndButton *setup_button)
{
#ifndef ANDROID
static const TCHAR *const COMMPort[] = {
_T("COM1"), _T("COM2"), _T("COM3"), _T("COM4"),
_T("COM5"), _T("COM6"), _T("COM7"), _T("COM8"),
_T("COM9"), _T("COM10"), _T("COM0"),
NULL
};
static const TCHAR *const tSpeed[] = {
_T("1200"), _T("2400"), _T("4800"), _T("9600"),
_T("19200"), _T("38400"), _T("57600"), _T("115200"),
NULL
};
#endif
if (port_field != NULL) {
DataFieldEnum *dfe = (DataFieldEnum *)port_field->GetDataField();
for (unsigned i = 0; port_types[i].label != NULL; i++) {
dfe->addEnumText(gettext(port_types[i].label));
if (port_types[i].type == config.port_type)
dfe->Set(i);
}
#ifdef ANDROID
JNIEnv *env = Java::GetEnv();
jobjectArray bonded = BluetoothHelper::list(env);
if (bonded != NULL) {
jsize n = env->GetArrayLength(bonded) / 2;
for (jsize i = 0; i < n; ++i) {
jstring address = (jstring)env->GetObjectArrayElement(bonded, i * 2);
if (address == NULL)
continue;
const char *address2 = env->GetStringUTFChars(address, NULL);
if (address2 == NULL)
continue;
jstring name = (jstring)env->GetObjectArrayElement(bonded, i * 2 + 1);
const char *name2 = name != NULL
? env->GetStringUTFChars(name, NULL)
: NULL;
dfe->addEnumText(address2, name2);
env->ReleaseStringUTFChars(address, address2);
if (name2 != NULL)
env->ReleaseStringUTFChars(name, name2);
}
env->DeleteLocalRef(bonded);
if (config.port_type == DeviceConfig::RFCOMM &&
!config.bluetooth_mac.empty()) {
if (!dfe->Exists(config.bluetooth_mac))
dfe->addEnumText(config.bluetooth_mac);
dfe->SetAsString(config.bluetooth_mac);
}
}
#else
dfe->addEnumTexts(COMMPort);
switch (config.port_type) {
case DeviceConfig::SERIAL:
dfe->Set(config.port_index + num_port_types);
break;
case DeviceConfig::DISABLED:
case DeviceConfig::RFCOMM:
case DeviceConfig::AUTO:
case DeviceConfig::INTERNAL:
case DeviceConfig::TCP_LISTENER:
break;
}
#endif
port_field->RefreshDisplay();
}
if (speed_field != NULL) {
#ifdef ANDROID
speed_field->hide();
#else
DataFieldEnum *dfe = (DataFieldEnum *)speed_field->GetDataField();
dfe->addEnumTexts(tSpeed);
dfe->Set(config.speed_index);
speed_field->RefreshDisplay();
#endif
}
if (driver_field) {
DataFieldEnum *dfe = (DataFieldEnum *)driver_field->GetDataField();
const TCHAR *DeviceName;
for (unsigned i = 0; (DeviceName = devRegisterGetName(i)) != NULL; i++)
dfe->addEnumText(DeviceName);
dfe->Sort(1);
dfe->SetAsString(config.driver_name);
driver_field->RefreshDisplay();
}
if (setup_button != NULL)
setup_button->set_visible(config.IsVega());
UpdateDeviceControlVisibility(*port_field, *speed_field, *driver_field);
}
DeviceConfig* DefaultConfigFactory::getDeviceConfig() {
DeviceConfig* dc = new DeviceConfig();
dc->setMan ("");
dc->setMod ("");
dc->setOem ("");
dc->setFwv ("");
dc->setSwv ("");
dc->setHwv ("");
dc->setDevID ("funambol-client");
dc->setDevType ("workstation");
dc->setDsV ("");
dc->setUtc (true);
dc->setLoSupport (false);
dc->setNocSupport (false);
dc->setLogLevel (LOG_LEVEL_INFO);
dc->setMaxObjSize (0);
dc->setDevInfHash ("");
return dc;
}