libcyberradio 22.01.24
RadioHandler.cpp
1/***************************************************************************
2 * \file RadioHandler.cpp
3 * \brief Defines the basic radio handler interface for an NDR-class radio.
4 * \author DA
5 * \author NH
6 * \author MN
7 * \copyright (c) 2017 CyberRadio Solutions, Inc. All rights reserved.
8 *
9 ***************************************************************************/
10
11#include "LibCyberRadio/Driver/RadioHandler.h"
12#include "LibCyberRadio/Common/Pythonesque.h"
13#include <boost/format.hpp>
14#include <boost/lexical_cast.hpp>
15#include <algorithm>
16#include <sstream>
17#include <iomanip>
18#include <cstdio>
19#include <cstring>
20#include <ctime>
21#include <arpa/inet.h>
22
23namespace LibCyberRadio
24{
25
26 namespace Driver
27 {
28 RadioHandler::RadioHandler(
29 const std::string& name,
30 int numTuner,
31 int tunerIndexBase,
32 int numWbddc,
33 int wbddcIndexBase,
34 int numNbddc,
35 int nbddcIndexBase,
36 int numTunerBoards,
37 int maxTunerBw,
38 int numTransmitter,
39 int transmitterIndexBase,
40 int numDuc,
41 int ducIndexBase,
42 int numWbddcGroups,
43 int wbddcGroupIndexBase,
44 int numNbddcGroups,
45 int nbddcGroupIndexBase,
46 int numDdcGroups,
47 int ddcGroupIndexBase,
48 int numDataPorts,
49 int dataPortIndexBase,
50 int numSimpleIpSetups,
51 double adcRate,
52 VitaIfSpec ifSpec,
53 bool debug) :
54 Configurable(name, debug),
55 _numTuner(numTuner),
56 _tunerIndexBase(tunerIndexBase),
57 _numWbddc(numWbddc),
58 _wbddcIndexBase(wbddcIndexBase),
59 _numNbddc(numNbddc),
60 _nbddcIndexBase(nbddcIndexBase),
61 _numTunerBoards(numTunerBoards),
62 _maxTunerBw(maxTunerBw),
63 _numTransmitter(numTransmitter),
64 _transmitterIndexBase(transmitterIndexBase),
65 _numDuc(numDuc),
66 _ducIndexBase(ducIndexBase),
67 _numWbddcGroups(numWbddcGroups),
68 _wbddcGroupIndexBase(wbddcGroupIndexBase),
69 _numNbddcGroups(numNbddcGroups),
70 _nbddcGroupIndexBase(nbddcGroupIndexBase),
71 _numDdcGroups(numDdcGroups),
72 _ddcGroupIndexBase(ddcGroupIndexBase),
73 _numDataPorts(numDataPorts),
74 _dataPortIndexBase(dataPortIndexBase),
75 _numSimpleIpSetups(numSimpleIpSetups),
76 _adcRate(adcRate),
77 _ifSpec(ifSpec),
78 _configMode(0),
79 _coherentMode(0),
80 _freqNormalization(0),
81 _gpsEnabled(0),
82 _referenceMode(0),
83 _referenceTuningVoltage(0),
84 _referenceBypass(0),
85 _calibFrequency(0.0),
86 _lastCmdErrorInfo(""),
87 _defaultTimeout(2.0),
88 _defaultDeviceInfo(0)
89 {
90 _versionInfo["model"] = "N/A";
91 _versionInfo["serialNumber"] = "N/A";
92 _versionInfo["unitRevision"] = "N/A";
93 _versionInfo["softwareVersion"] = "N/A";
94 _versionInfo["firmwareVersion"] = "N/A";
95 _versionInfo["firmwareDate"] = "N/A";
96 _versionInfo["referenceVersion"] = "N/A";
97 _versionInfo["hardwareVersion"] = "N/A";
98 this->initConfigurationDict();
99 }
100
101 RadioHandler::~RadioHandler()
102 {
103 if ( isConnected() )
104 {
105 disconnect();
106 }
107 for ( TunerComponentDict::iterator it = _tuners.begin();
108 it != _tuners.end(); it++)
109 {
110 delete it->second;
111 }
112 for ( WbddcComponentDict::iterator it = _wbddcs.begin();
113 it != _wbddcs.end(); it++)
114 {
115 delete it->second;
116 }
117 for ( NbddcComponentDict::iterator it = _nbddcs.begin();
118 it != _nbddcs.end(); it++)
119 {
120 delete it->second;
121 }
122 for ( TransmitterComponentDict::iterator it = _txs.begin();
123 it != _txs.end(); it++)
124 {
125 delete it->second;
126 }
127 for ( DataPortDict::iterator it = _dataPorts.begin();
128 it != _dataPorts.end(); it++)
129 {
130 delete it->second;
131 }
132 for ( DucComponentDict::iterator it = _ducs.begin();
133 it != _ducs.end(); it++)
134 {
135 delete it->second;
136 }
137 for ( WbddcGroupComponentDict::iterator it = _wbddcGroups.begin();
138 it != _wbddcGroups.end(); it++)
139 {
140 delete it->second;
141 }
142 for ( NbddcGroupComponentDict::iterator it = _nbddcGroups.begin();
143 it != _nbddcGroups.end(); it++)
144 {
145 delete it->second;
146 }
147 for ( SimpleIpSetupDict::iterator it = _simpleIpSetups.begin();
148 it != _simpleIpSetups.end(); it++)
149 {
150 delete it->second;
151 }
152 }
153
154 RadioHandler::RadioHandler(const RadioHandler &other) :
155 Configurable(other)
156 {
157 _connModesSupported = other._connModesSupported;
158 _numTuner = other._numTuner;
159 _tunerIndexBase = other._tunerIndexBase;
160 _numWbddc = other._numWbddc;
161 _wbddcIndexBase = other._wbddcIndexBase;
162 _numNbddc = other._numNbddc;
163 _nbddcIndexBase = other._nbddcIndexBase;
164 _numTunerBoards = other._numTunerBoards;
165 _maxTunerBw = other._maxTunerBw;
166 _numTransmitter = other._numTransmitter;
167 _transmitterIndexBase = other._transmitterIndexBase;
168 _numDuc = other._numDuc;
169 _ducIndexBase = other._ducIndexBase;
170 _numWbddcGroups = other._numWbddcGroups;
171 _wbddcGroupIndexBase = other._wbddcGroupIndexBase;
172 _numNbddcGroups = other._numNbddcGroups;
173 _nbddcGroupIndexBase = other._nbddcGroupIndexBase;
174 _numDdcGroups = other._numDdcGroups;
175 _ddcGroupIndexBase = other._ddcGroupIndexBase;
176 _numDataPorts = other._numDataPorts;
177 _dataPortIndexBase = other._dataPortIndexBase;
178 _numSimpleIpSetups = other._numSimpleIpSetups;
179 _adcRate = other._adcRate;
180 _ifSpec = other._ifSpec;
181 _configMode = other._configMode;
182 _coherentMode = other._coherentMode;
183 _freqNormalization = other._freqNormalization;
184 _gpsEnabled = other._gpsEnabled;
185 _referenceMode = other._referenceMode;
186 _referenceTuningVoltage = other._referenceTuningVoltage;
187 _referenceBypass = other._referenceBypass;
188 _calibFrequency = other._calibFrequency;
189 _lastCmdErrorInfo = other._lastCmdErrorInfo;
190 _transport = other._transport;
191 _versionInfo = other._versionInfo;
192 _connectionInfo = other._connectionInfo;
193 _defaultTimeout = other._defaultTimeout;
194 _defaultDeviceInfo = other._defaultDeviceInfo;
195 }
196
197 RadioHandler& RadioHandler::operator=(const RadioHandler& other)
198 {
199 Configurable::operator=(other);
200 // Block self-assignment
201 if (this != &other)
202 {
203 _connModesSupported = other._connModesSupported;
204 _numTuner = other._numTuner;
205 _tunerIndexBase = other._tunerIndexBase;
206 _numWbddc = other._numWbddc;
207 _wbddcIndexBase = other._wbddcIndexBase;
208 _numNbddc = other._numNbddc;
209 _nbddcIndexBase = other._nbddcIndexBase;
210 _numTunerBoards = other._numTunerBoards;
211 _maxTunerBw = other._maxTunerBw;
212 _numTransmitter = other._numTransmitter;
213 _transmitterIndexBase = other._transmitterIndexBase;
214 _numDuc = other._numDuc;
215 _ducIndexBase = other._ducIndexBase;
216 _numWbddcGroups = other._numWbddcGroups;
217 _wbddcGroupIndexBase = other._wbddcGroupIndexBase;
218 _numNbddcGroups = other._numNbddcGroups;
219 _nbddcGroupIndexBase = other._nbddcGroupIndexBase;
220 _numDdcGroups = other._numDdcGroups;
221 _ddcGroupIndexBase = other._ddcGroupIndexBase;
222 _numDataPorts = other._numDataPorts;
223 _dataPortIndexBase = other._dataPortIndexBase;
224 _numSimpleIpSetups = other._numSimpleIpSetups;
225 _adcRate = other._adcRate;
226 _ifSpec = other._ifSpec;
227 _configMode = other._configMode;
228 _coherentMode = other._coherentMode;
229 _freqNormalization = other._freqNormalization;
230 _gpsEnabled = other._gpsEnabled;
231 _referenceMode = other._referenceMode;
232 _referenceTuningVoltage = other._referenceTuningVoltage;
233 _referenceBypass = other._referenceBypass;
234 _calibFrequency = other._calibFrequency;
235 _lastCmdErrorInfo = other._lastCmdErrorInfo;
236 _transport = other._transport;
237 _versionInfo = other._versionInfo;
238 _connectionInfo = other._connectionInfo;
239 _defaultTimeout = other._defaultTimeout;
240 _defaultDeviceInfo = other._defaultDeviceInfo;
241 }
242 return *this;
243 }
244
245 bool RadioHandler::isConnected() const
246 {
247 return _transport.isConnected();
248 }
249
250 BasicStringStringDict RadioHandler::getVersionInfo()
251 {
252 return _versionInfo;
253 }
254
255 BasicStringStringDict RadioHandler::getConnectionInfo()
256 {
257 return _connectionInfo;
258 }
259
260 bool RadioHandler::connect(const std::string &mode, const std::string &host_or_dev, const int port_or_baudrate)
261 {
262 this->debug("[RadioHandler::connect] Called; mode=\"%s\", HorD=\"%s\", PorB=%d\n", mode.c_str(), host_or_dev.c_str(), port_or_baudrate);
263 bool ret = false;
264 _connectionInfo = BasicStringStringDict();
265 // Sanity check: Make sure radio supports the given connection mode
266 if ( isConnectionModeSupported(mode) )
267 {
268 ret = _transport.connect(mode, host_or_dev, port_or_baudrate);
269 this->debug("[RadioHandler::connect] Connect result: %s\n", debugBool(ret));
270 if (ret)
271 {
272 _connectionInfo["mode"] = mode;
273 if ( (mode == "tcp") or (mode == "udp") )
274 {
275 _connectionInfo["hostname"] = host_or_dev;
276 _connectionInfo["port"] = ( boost::format("%d") % port_or_baudrate ).str();
277 }
278 else if ( (mode == "tty") )
279 {
280 _connectionInfo["device"] = host_or_dev;
281 _connectionInfo["baudrate"] = ( boost::format("%d") % port_or_baudrate ).str();
282 }
283 this->debug("[RadioHandler::connect] Querying configuration\n");
284 this->queryConfiguration();
285 }
286 else
287 _lastCmdErrorInfo = _transport.getLastCommandErrorInfo();
288 }
289 else
290 {
291 std::ostringstream oss;
292 oss << "Unsupported connection mode: " << mode;
293 _lastCmdErrorInfo = oss.str();
294 }
295 this->debug("[RadioHandler::connect] Returning %s\n", debugBool(ret));
296 return ret;
297 }
298
299 void RadioHandler::disconnect()
300 {
301 this->debug("[RadioHandler::disconnect] Called\n");
302 if (_transport.isConnected())
303 _transport.disconnect();
304 this->debug("[RadioHandler::disconnect] Returning\n");
305 }
306
307 BasicStringList RadioHandler::sendCommand(const std::string &cmdString, double timeout)
308 {
309 this->debug("[RadioHandler::sendCommand] Called; cmd=\"%s\"\n",
310 Pythonesque::Strip(cmdString).c_str());
311 BasicStringList ret;
312 _lastCmdErrorInfo = "";
313 if ( _transport.sendCommand(cmdString) )
314 {
315 ret = _transport.receive(timeout);
316 }
317 else
318 _lastCmdErrorInfo = _transport.getLastCommandErrorInfo();
319 // This covers the case where the act of sending the command itself
320 // generates an error, but not the case where the command/response happens
321 // but the response contains an error message. This section looks for
322 // error messages in the response and sets last command error info accordingly.
323 BasicStringList::iterator it;
324 for (it = ret.begin(); it != ret.end(); it++)
325 {
326 if ( it->find("ERROR") != std::string::npos )
327 {
328 _lastCmdErrorInfo = Pythonesque::Replace(*it, "ERROR: ", "");
329 break;
330 }
331 }
332 // If the first line of the response just echoed the command, remove it
333 if ( (ret.size() > 0) && (ret.front() == Pythonesque::Strip(cmdString)) )
334 ret.erase(ret.begin());
335 // Debug print
336 this->debug("[RadioHandler::sendCommand] Returning %lu elements\n", ret.size());
337 for (it = ret.begin(); it != ret.end(); it++)
338 this->debug("[RadioHandler::sendCommand] -- %s\n", it->c_str());
339 return ret;
340 }
341
342 void RadioHandler::queryConfiguration()
343 {
344 this->queryVersionInfo();
345 if ( this->queryRadioConfiguration() )
346 this->updateConfigurationDict();
347 for ( TunerComponentDict::iterator it = _tuners.begin();
348 it != _tuners.end(); it++)
349 {
350 it->second->queryConfiguration();
351 }
352 for ( WbddcComponentDict::iterator it = _wbddcs.begin();
353 it != _wbddcs.end(); it++)
354 {
355 it->second->queryConfiguration();
356 }
357 for ( NbddcComponentDict::iterator it = _nbddcs.begin();
358 it != _nbddcs.end(); it++)
359 {
360 it->second->queryConfiguration();
361 }
362 for ( TransmitterComponentDict::iterator it = _txs.begin();
363 it != _txs.end(); it++)
364 {
365 it->second->queryConfiguration();
366 }
367 for ( DataPortDict::iterator it = _dataPorts.begin();
368 it != _dataPorts.end(); it++)
369 {
370 it->second->queryConfiguration();
371 }
372 for ( DucComponentDict::iterator it = _ducs.begin();
373 it != _ducs.end(); it++)
374 {
375 it->second->queryConfiguration();
376 }
377 for ( WbddcGroupComponentDict::iterator it = _wbddcGroups.begin();
378 it != _wbddcGroups.end(); it++)
379 {
380 it->second->queryConfiguration();
381 }
382 for ( NbddcGroupComponentDict::iterator it = _nbddcGroups.begin();
383 it != _nbddcGroups.end(); it++)
384 {
385 it->second->queryConfiguration();
386 }
387 for ( SimpleIpSetupDict::iterator it = _simpleIpSetups.begin();
388 it != _simpleIpSetups.end(); it++)
389 {
390 it->second->queryConfiguration();
391 }
392 }
393
394 bool RadioHandler::setConfiguration(ConfigurationDict& cfg)
395 {
396 this->debug("[RadioHandler::setConfiguration] Called\n");
397 // Call the parent version.
398 bool ret = Configurable::setConfiguration(cfg);
399 int adjCfg = _configMode;
400 int adjCoh = _coherentMode;
401 int adjFnr = _freqNormalization;
402 int adjGps = _gpsEnabled;
403 int adjRef = _referenceMode;
404 int adjRtv = _referenceTuningVoltage;
405 int adjByp = _referenceBypass;
406 double adjCal = _calibFrequency;
407 if ( cfg.find("configMode") != cfg.end() )
408 {
409 adjCfg = getConfigurationValueAsInt("configMode");
410 ret &= this->executeConfigModeCommand(adjCfg);
411 }
412 if ( cfg.find("coherentMode") != cfg.end() )
413 {
414 adjCoh = getConfigurationValueAsInt("coherentMode");
415 ret &= this->executeCoherentModeCommand(adjCoh);
416 }
417 if ( cfg.find("freqNormalization") != cfg.end() )
418 {
419 adjFnr = getConfigurationValueAsInt("freqNormalization");
420 ret &= this->executeFreqNormalizationCommand(adjFnr);
421 }
422 if ( cfg.find("gpsEnabled") != cfg.end() )
423 {
424 adjGps = getConfigurationValueAsInt("gpsEnabled");
425 ret &= this->executeGpsEnabledCommand(adjGps);
426 }
427 if ( cfg.find("referenceMode") != cfg.end() )
428 {
429 adjRef = getConfigurationValueAsInt("referenceMode");
430 ret &= this->executeReferenceModeCommand(adjRef);
431 }
432 if ( cfg.find("referenceTuningVoltage") != cfg.end() )
433 {
434 adjRtv = getConfigurationValueAsInt("referenceTuningVoltage");
435 ret &= this->executeReferenceVoltageCommand(adjRtv);
436 }
437 if ( cfg.find("bypassMode") != cfg.end() )
438 {
439 adjByp = getConfigurationValueAsInt("bypassMode");
440 ret &= this->executeReferenceBypassCommand(adjByp);
441 }
442 if ( cfg.find("calibFrequency") != cfg.end() )
443 {
444 adjCal = getConfigurationValueAsDbl("calibFrequency");
445 ret &= this->executeCalibFrequencyCommand(adjCal);
446 }
447 if ( ret )
448 {
449 _configMode = adjCfg;
450 _coherentMode = adjCoh;
451 _freqNormalization = adjFnr;
452 _gpsEnabled = adjGps;
453 _referenceMode = adjRef;
454 _referenceTuningVoltage = adjRtv;
455 _referenceBypass = adjByp;
456 _calibFrequency = adjCal;
457 updateConfigurationDict();
458 }
459 this->debug("[RadioHandler::setConfiguration] Returning\n");
460 return ret;
461 }
462
463 std::string RadioHandler::getLastCommandErrorInfo() const
464 {
465 return _lastCmdErrorInfo;
466 }
467
468 bool RadioHandler::sendReset(int resetType)
469 {
470 return this->executeResetCommand(resetType);
471 }
472
473 bool RadioHandler::getPps()
474 {
475 return this->executePpsQuery();
476 }
477
478 bool RadioHandler::setTimeNextPps(bool checkTime, bool useGpsTime)
479 {
480 bool ret = this->getPps();
481 if ( ret )
482 {
483 // Determine target time -- either the next whole second
484 // after current system time, or GPS time, as requested.
485 time_t targetTime = time(NULL) + 1;
486 std::string adjTime;
487 if ( useGpsTime )
488 {
489 // Set target time based on GPS time
490 adjTime = "G";
491 ret = this->executeTimeCommand(adjTime);
492 }
493 else
494 {
495 // Set target time based on system time
496 adjTime = boost::lexical_cast<std::string>(targetTime);
497 ret = this->executeTimeCommand(adjTime);
498 }
499 if ( ret )
500 {
501 if ( checkTime )
502 {
503 time_t radioUtc = this->getTimeNextPps();
504 ret = (radioUtc == targetTime);
505 }
506 }
507 }
508 else
509 {
510 ret = false;
511 }
512 return ret;
513 }
514
515 time_t RadioHandler::getTimeNow()
516 {
517 time_t ret = 0;
518 std::string adjTime;
519 this->debug("[RadioHandler::getTimeNow] Executing time query\n");
520 if ( this->executeTimeQuery(adjTime) )
521 {
522 this->debug("[RadioHandler::getTimeNow] -- query result: %s\n", adjTime.c_str());
523 ret = (time_t)boost::lexical_cast<unsigned int>(adjTime);
524 //this->debug("[RadioHandler::getTimeNow] -- converted: %lu\n", ret);
525 }
526 return ret;
527 }
528
529 time_t RadioHandler::getTimeNextPps()
530 {
531 time_t ret = 0;
532 bool ok = this->getPps();
533 if ( ok )
534 {
535 ret = this->getTimeNow();
536 }
537 return ret;
538 }
539
540 unsigned int RadioHandler::getStatus()
541 {
542 unsigned int ret = 0;
543 unsigned int stat = 0;
544 if ( this->executeStatusQuery(stat) )
545 {
546 ret = stat;
547 }
548 return ret;
549 }
550
551 unsigned int RadioHandler::getTstatus()
552 {
553 unsigned int ret = 0;
554 unsigned int stat = 0;
555 if ( this->executeTstatusQuery(stat) )
556 {
557 ret = stat;
558 }
559 return ret;
560 }
561
562 bool RadioHandler::setReferenceMode(int mode)
563 {
564 ConfigurationDict cfg;
565 cfg["referenceMode"] = mode;
566 return this->setConfiguration(cfg);
567 }
568
569 bool RadioHandler::setBypassMode(int mode)
570 {
571 ConfigurationDict cfg;
572 cfg["bypassMode"] = mode;
573 return this->setConfiguration(cfg);
574 }
575
576 bool RadioHandler::setTimeAdjustment(int tunerIndex, int timeAdjustValue)
577 {
578 bool ret = false;
579 TunerComponentDict::const_iterator it = _tuners.find(tunerIndex);
580 if ( it != _tuners.end() )
581 ret = it->second->setTimingAdjustment(timeAdjustValue);
582 return ret;
583 }
584
585 BasicDoubleList RadioHandler::getGpsPosition()
586 {
587 BasicDoubleList ret = {0.0, 0.0};
588 double lat = 0.0;
589 double lon = 0.0;
590 if ( this->executeGpsPositionQuery(lat, lon) )
591 {
592 ret[0] = lat;
593 ret[1] = lon;
594 }
595 return ret;
596 }
597
598 int RadioHandler::getTemperature()
599 {
600 int ret = 0;
601 int temp = 0;
602 if ( this->executeTemperatureQuery(temp) )
603 {
604 ret = temp;
605 }
606 return ret;
607 }
608
609 int RadioHandler::getNumDataPorts() const
610 {
611 return _numDataPorts;
612 }
613
614 int RadioHandler::getGpioOutput()
615 {
616 int ret = 0;
617 int value = 0;
618 if ( this->executeGpioStaticQuery(value) )
619 {
620 ret = value;
621 }
622 return ret;
623 }
624
625 BasicIntList RadioHandler::getGpioOutputByIndex(int index)
626 {
627 BasicIntList ret = {0, 0, 0};
628 int value = 0;
629 int duration = 0;
630 int loop = 0;
631 if ( this->executeGpioSequenceQuery(index, value, duration, loop) )
632 {
633 ret[0] = value;
634 ret[1] = duration;
635 ret[2] = loop;
636 }
637 return ret;
638 }
639
640 bool RadioHandler::setGpioOutput(int value)
641 {
642 bool ret = false;
643 int adjValue = value;
644 if ( this->executeGpioStaticCommand(adjValue) )
645 ret = true;
646 return ret;
647 }
648
649 bool RadioHandler::setGpioOutputByIndex(int index, int value,
650 int duration, int loop, int go)
651 {
652 bool ret = false;
653 int adjValue = value;
654 int adjDur = duration;
655 int adjLoop = loop;
656 int adjGo = go;
657 if ( this->executeGpioSequenceCommand(index, adjValue, adjDur, adjLoop, adjGo) )
658 ret = true;
659 return ret;
660 }
661
662 double RadioHandler::getCalibrationFrequency() const
663 {
664 return _calibFrequency;
665 }
666
667 bool RadioHandler::setCalibrationFrequency(double freq)
668 {
669 bool ret = false;
670 if ( _config.find("calibFrequency") != _config.end() )
671 {
672 ConfigurationDict cfg;
673 cfg["calibFrequency"] = freq;
674 ret = this->setConfiguration(cfg);
675 }
676 return ret;
677 }
678
679 BasicIntList RadioHandler::getDataPortIndexRange() const
680 {
681 BasicIntList ret;
682 for (int num = _dataPortIndexBase; num < _dataPortIndexBase + _numDataPorts; num++)
683 ret.push_back(num);
684 return ret;
685 }
686
687 int RadioHandler::getNumDataPortDipEntries() const
688 {
689 int ret;
690 DataPortDict::const_iterator it = _dataPorts.begin();
691 if ( it != _dataPorts.end() )
692 ret = it->second->getNumDestEntries();
693 return ret;
694 }
695
696 BasicIntList RadioHandler::getDataPortDipEntryIndexRange() const
697 {
698 BasicIntList ret;
699 DataPortDict::const_iterator it = _dataPorts.begin();
700 if ( it != _dataPorts.end() )
701 ret = it->second->getDestEntryIndexRange();
702 return ret;
703 }
704
705 BasicStringList RadioHandler::getConnectionModeList() const
706 {
707 return _connModesSupported;
708 }
709
710 bool RadioHandler::isConnectionModeSupported(const std::string &mode) const
711 {
712 bool ret = false;
713 if (std::find(_connModesSupported.begin(), _connModesSupported.end(), mode) != _connModesSupported.end())
714 {
715 ret = true;
716 }
717 return ret;
718 }
719
720 double RadioHandler::getAdcRate() const
721 {
722 return _adcRate;
723 }
724
725 int RadioHandler::getVitaHeaderSize() const
726 {
727 return _ifSpec.headerSizeWords * 4;
728 }
729
730 int RadioHandler::getVitaPayloadSize() const
731 {
732 return _ifSpec.payloadSizeWords * 4;
733 }
734
735 int RadioHandler::getVitaTailSize() const
736 {
737 return _ifSpec.tailSizeWords * 4;
738 }
739
740 bool RadioHandler::isByteswapped() const
741 {
742 // Get our byte order
743 const char *ourByteOrder = "little";
744 if ( htonl(0xDEAD) == 0xDEAD )
745 ourByteOrder = "big";
746 // Compare it to the IF spec
747 return ( strcmp(ourByteOrder, _ifSpec.byteOrder) != 0 );
748 }
749
750 bool RadioHandler::isIqSwapped() const
751 {
752 return _ifSpec.iqSwapped;
753 }
754
755 const char* RadioHandler::getByteOrder() const
756 {
757 return _ifSpec.byteOrder;
758 }
759
760 int RadioHandler::getNumTuner() const
761 {
762 return _numTuner;
763 }
764
765 int RadioHandler::getNumTunerBoards() const
766 {
767 return _numTunerBoards;
768 }
769
770 BasicIntList RadioHandler::getTunerIndexRange() const
771 {
772 BasicIntList ret;
773 for (int num = _tunerIndexBase; num < _tunerIndexBase + _numTuner; num++)
774 ret.push_back(num);
775 return ret;
776 }
777
778 BasicDoubleList RadioHandler::getTunerFrequencyRange() const
779 {
780 BasicDoubleList ret;
781 TunerComponentDict::const_iterator it = _tuners.begin();
782 if ( it != _tuners.end() )
783 ret = it->second->getFrequencyRange();
784 return ret;
785 }
786
787 double RadioHandler::getTunerFrequencyRes() const
788 {
789 double ret = 0.0;
790 TunerComponentDict::const_iterator it = _tuners.begin();
791 if ( it != _tuners.end() )
792 ret = it->second->getFrequencyRes();
793 return ret;
794 }
795
796 double RadioHandler::getTunerFrequencyUnit() const
797 {
798 double ret = 0.0;
799 TunerComponentDict::const_iterator it = _tuners.begin();
800 if ( it != _tuners.end() )
801 ret = it->second->getFrequencyUnit();
802 return ret;
803 }
804
805 BasicDoubleList RadioHandler::getTunerAttenuationRange() const
806 {
807 BasicDoubleList ret;
808 TunerComponentDict::const_iterator it = _tuners.begin();
809 if ( it != _tuners.end() )
810 ret = it->second->getAttenuationRange();
811 return ret;
812 }
813
814 double RadioHandler::getTunerAttenuationRes() const
815 {
816 double ret = 0.0;
817 TunerComponentDict::const_iterator it = _tuners.begin();
818 if ( it != _tuners.end() )
819 ret = it->second->getAttenuationRes();
820 return ret;
821 }
822
823 bool RadioHandler::isTunerEnabled(int index) const
824 {
825 bool ret = false;
826 TunerComponentDict::const_iterator it = _tuners.find(index);
827 if ( it != _tuners.end() )
828 ret = it->second->isEnabled();
829 return ret;
830 }
831
832 bool RadioHandler::enableTuner(int index, bool enabled)
833 {
834 bool ret = false;
835 TunerComponentDict::const_iterator it = _tuners.find(index);
836 if ( it != _tuners.end() )
837 ret = it->second->enable(enabled);
838 return ret;
839 }
840
841 bool RadioHandler::disableTuner(int index)
842 {
843 return enableTuner(index, false);
844 }
845
846 double RadioHandler::getTunerFrequency(int index) const
847 {
848 double ret = 0.0;
849 TunerComponentDict::const_iterator it = _tuners.find(index);
850 if ( it != _tuners.end() )
851 ret = it->second->getFrequency();
852 return ret;
853 }
854
855 bool RadioHandler::setTunerFrequency(int index, double freq)
856 {
857 bool ret = false;
858 TunerComponentDict::const_iterator it = _tuners.find(index);
859 if ( it != _tuners.end() )
860 ret = it->second->setFrequency(freq);
861 return ret;
862 }
863
864 double RadioHandler::getTunerAttenuation(int index) const
865 {
866 double ret = 0.0;
867 TunerComponentDict::const_iterator it = _tuners.find(index);
868 if ( it != _tuners.end() )
869 ret = it->second->getAttenuation();
870 return ret;
871 }
872
873 bool RadioHandler::setTunerAttenuation(int index, double atten)
874 {
875 bool ret = false;
876 TunerComponentDict::const_iterator it = _tuners.find(index);
877 if ( it != _tuners.end() )
878 ret = it->second->setAttenuation(atten);
879 return ret;
880 }
881
882 int RadioHandler::getTunerFilter(int index) const
883 {
884 int ret = 0;
885 TunerComponentDict::const_iterator it = _tuners.find(index);
886 if ( it != _tuners.end() )
887 ret = it->second->getFilter();
888 return ret;
889 }
890
891 bool RadioHandler::setTunerFilter(int index, int filter)
892 {
893 bool ret = false;
894 TunerComponentDict::const_iterator it = _tuners.find(index);
895 if ( it != _tuners.end() )
896 ret = it->second->setFilter(filter);
897 return ret;
898 }
899
900 ConfigurationDict RadioHandler::getTunerConfiguration(int index) const
901 {
902 ConfigurationDict ret;
903 TunerComponentDict::const_iterator it = _tuners.find(index);
904 if ( it != _tuners.end() )
905 ret = it->second->getConfiguration();
906 return ret;
907 }
908
909 bool RadioHandler::setTunerConfiguration(int index, ConfigurationDict& cfg)
910 {
911 bool ret = false;
912 TunerComponentDict::const_iterator it = _tuners.find(index);
913 if ( it != _tuners.end() )
914 ret = it->second->setConfiguration(cfg);
915 return ret;
916 }
917
918 int RadioHandler::getNumWbddc() const
919 {
920 return _numWbddc;
921 }
922
923 BasicIntList RadioHandler::getWbddcIndexRange() const
924 {
925 BasicIntList ret;
926 for (int num = _wbddcIndexBase; num < _wbddcIndexBase + _numWbddc; num++)
927 ret.push_back(num);
928 return ret;
929 }
930
931 bool RadioHandler::isWbddcTunable() const
932 {
933 bool ret = false;
934 WbddcComponentDict::const_iterator it = _wbddcs.begin();
935 if ( it != _wbddcs.end() )
936 ret = it->second->isTunable();
937 return ret;
938 }
939
940 bool RadioHandler::isWbddcSelectableSource() const
941 {
942 bool ret = false;
943 WbddcComponentDict::const_iterator it = _wbddcs.begin();
944 if ( it != _wbddcs.end() )
945 ret = it->second->isSourceSelectable();
946 return ret;
947 }
948
949 BasicDoubleList RadioHandler::getWbddcFrequencyRange() const
950 {
951 BasicDoubleList ret;
952 WbddcComponentDict::const_iterator it = _wbddcs.begin();
953 if ( it != _wbddcs.end() )
954 ret = it->second->getFrequencyRange();
955 return ret;
956 }
957
958 double RadioHandler::getWbddcFrequencyRes() const
959 {
960 double ret = 0.0;
961 WbddcComponentDict::const_iterator it = _wbddcs.begin();
962 if ( it != _wbddcs.end() )
963 ret = it->second->getFrequencyRes();
964 return ret;
965 }
966
967 double RadioHandler::getWbddcFrequencyUnit() const
968 {
969 double ret = 0.0;
970 WbddcComponentDict::const_iterator it = _wbddcs.begin();
971 if ( it != _wbddcs.end() )
972 ret = it->second->getFrequencyUnit();
973 return ret;
974 }
975
976 WbddcRateSet RadioHandler::getWbddcRateSet() const
977 {
978 WbddcRateSet ret;
979 WbddcComponentDict::const_iterator it = _wbddcs.begin();
980 if ( it != _wbddcs.end() )
981 ret = it->second->getRateSet();
982 return ret;
983 }
984
985 BasicDoubleList RadioHandler::getWbddcRateList() const
986 {
987 BasicDoubleList ret;
988 WbddcComponentDict::const_iterator it = _wbddcs.begin();
989 if ( it != _wbddcs.end() )
990 ret = it->second->getRateList();
991 return ret;
992 }
993
994 bool RadioHandler::isWbddcEnabled(int index) const
995 {
996 bool ret = false;
997 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
998 if ( it != _wbddcs.end() )
999 ret = it->second->isEnabled();
1000 return ret;
1001 }
1002
1003 bool RadioHandler::enableWbddc(int index, bool enabled)
1004 {
1005 bool ret = false;
1006 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1007 if ( it != _wbddcs.end() )
1008 ret = it->second->enable(enabled);
1009 return ret;
1010 }
1011
1012 bool RadioHandler::disableWbddc(int index)
1013 {
1014 return enableWbddc(index, false);
1015 }
1016
1017 double RadioHandler::getWbddcFrequency(int index) const
1018 {
1019 double ret = 0.0;
1020 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1021 if ( it != _wbddcs.end() )
1022 ret = it->second->getFrequency();
1023 return ret;
1024 }
1025
1026 bool RadioHandler::setWbddcFrequency(int index, double freq)
1027 {
1028 bool ret = false;
1029 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1030 if ( it != _wbddcs.end() )
1031 ret = it->second->setFrequency(freq);
1032 return ret;
1033 }
1034
1035 int RadioHandler::getWbddcSource(int index) const
1036 {
1037 int ret = 0;
1038 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1039 if ( it != _wbddcs.end() )
1040 ret = it->second->getSource();
1041 return ret;
1042 }
1043
1044 bool RadioHandler::setWbddcSource(int index, int source)
1045 {
1046 bool ret = false;
1047 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1048 if ( it != _wbddcs.end() )
1049 ret = it->second->setSource(source);
1050 return ret;
1051 }
1052
1053 int RadioHandler::getWbddcRateIndex(int index) const
1054 {
1055 int ret = 0;
1056 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1057 if ( it != _wbddcs.end() )
1058 ret = it->second->getRateIndex();
1059 return ret;
1060 }
1061
1062 bool RadioHandler::setWbddcRateIndex(int index, int rateIndex)
1063 {
1064 bool ret = false;
1065 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1066 if ( it != _wbddcs.end() )
1067 ret = it->second->setRateIndex(rateIndex);
1068 return ret;
1069 }
1070
1071 int RadioHandler::getWbddcUdpDestination(int index) const
1072 {
1073 int ret = 0;
1074 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1075 if ( it != _wbddcs.end() )
1076 ret = it->second->getUdpDestination();
1077 return ret;
1078 }
1079
1080 bool RadioHandler::setWbddcUdpDestination(int index, int dest)
1081 {
1082 bool ret = false;
1083 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1084 if ( it != _wbddcs.end() )
1085 ret = it->second->setUdpDestination(dest);
1086 return ret;
1087 }
1088
1089 int RadioHandler::getWbddcVitaEnable(int index) const
1090 {
1091 int ret = 0;
1092 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1093 if ( it != _wbddcs.end() )
1094 ret = it->second->getVitaEnable();
1095 return ret;
1096 }
1097
1098 bool RadioHandler::setWbddcVitaEnable(int index, int enable)
1099 {
1100 bool ret = false;
1101 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1102 if ( it != _wbddcs.end() )
1103 ret = it->second->setVitaEnable(enable);
1104 return ret;
1105 }
1106
1107 unsigned int RadioHandler::getWbddcStreamId(int index) const
1108 {
1109 unsigned int ret = 0;
1110 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1111 if ( it != _wbddcs.end() )
1112 ret = it->second->getStreamId();
1113 return ret;
1114 }
1115
1116 bool RadioHandler::setWbddcStreamId(int index, unsigned int sid)
1117 {
1118 bool ret = false;
1119 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1120 if ( it != _wbddcs.end() )
1121 ret = it->second->setStreamId(sid);
1122 return ret;
1123 }
1124
1125 int RadioHandler::getWbddcDataPort(int index) const
1126 {
1127 int ret = 0;
1128 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1129 if ( it != _wbddcs.end() )
1130 ret = it->second->getDataPort();
1131 return ret;
1132 }
1133
1134 bool RadioHandler::setWbddcDataPort(int index, int port)
1135 {
1136 bool ret = false;
1137 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1138 if ( it != _wbddcs.end() )
1139 ret = it->second->setDataPort(port);
1140 return ret;
1141 }
1142
1143 bool RadioHandler::setWbddcRateSet(int index, const WbddcRateSet& set)
1144 {
1145 bool ret = false;
1146 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1147 if ( it != _wbddcs.end() )
1148 ret = it->second->setRateSet(set);
1149 return ret;
1150 }
1151
1152 ConfigurationDict RadioHandler::getWbddcConfiguration(int index) const
1153 {
1154 ConfigurationDict ret;
1155 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1156 if ( it != _wbddcs.end() )
1157 ret = it->second->getConfiguration();
1158 return ret;
1159 }
1160
1161 bool RadioHandler::setWbddcConfiguration(int index, ConfigurationDict& cfg)
1162 {
1163 bool ret = false;
1164 WbddcComponentDict::const_iterator it = _wbddcs.find(index);
1165 if ( it != _wbddcs.end() )
1166 ret = it->second->setConfiguration(cfg);
1167 return ret;
1168 }
1169
1170 int RadioHandler::getNumNbddc() const
1171 {
1172 return _numNbddc;
1173 }
1174
1175 BasicIntList RadioHandler::getNbddcIndexRange() const
1176 {
1177 BasicIntList ret;
1178 for (int num = _nbddcIndexBase; num < _nbddcIndexBase + _numNbddc; num++)
1179 ret.push_back(num);
1180 return ret;
1181 }
1182
1183 BasicDoubleList RadioHandler::getNbddcFrequencyRange() const
1184 {
1185 BasicDoubleList ret;
1186 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1187 if ( it != _nbddcs.end() )
1188 ret = it->second->getFrequencyRange();
1189 return ret;
1190 }
1191
1192 double RadioHandler::getNbddcFrequencyRes() const
1193 {
1194 double ret = 0.0;
1195 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1196 if ( it != _nbddcs.end() )
1197 ret = it->second->getFrequencyRes();
1198 return ret;
1199 }
1200
1201 double RadioHandler::getNbddcFrequencyUnit() const
1202 {
1203 double ret = 0.0;
1204 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1205 if ( it != _nbddcs.end() )
1206 ret = it->second->getFrequencyUnit();
1207 return ret;
1208 }
1209
1210 NbddcRateSet RadioHandler::getNbddcRateSet() const
1211 {
1212 NbddcRateSet ret;
1213 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1214 if ( it != _nbddcs.end() )
1215 ret = it->second->getRateSet();
1216 return ret;
1217 }
1218
1219 BasicDoubleList RadioHandler::getNbddcRateList() const
1220 {
1221 BasicDoubleList ret;
1222 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1223 if ( it != _nbddcs.end() )
1224 ret = it->second->getRateList();
1225 return ret;
1226 }
1227
1228 bool RadioHandler::isNbddcEnabled(int index) const
1229 {
1230 bool ret = false;
1231 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1232 if ( it != _nbddcs.end() )
1233 ret = it->second->isEnabled();
1234 return ret;
1235 }
1236
1237 bool RadioHandler::enableNbddc(int index, bool enabled)
1238 {
1239 bool ret = false;
1240 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1241 if ( it != _nbddcs.end() )
1242 ret = it->second->enable(enabled);
1243 return ret;
1244 }
1245
1246 bool RadioHandler::disableNbddc(int index)
1247 {
1248 return enableNbddc(index, false);
1249 }
1250
1251 ConfigurationDict RadioHandler::getNbddcConfiguration(int index) const
1252 {
1253 ConfigurationDict ret;
1254 NbddcComponentDict::const_iterator it = _nbddcs.find(index);
1255 if ( it != _nbddcs.end() )
1256 ret = it->second->getConfiguration();
1257 return ret;
1258 }
1259
1260 bool RadioHandler::setNbddcConfiguration(int index, ConfigurationDict& cfg)
1261 {
1262 bool ret = false;
1263 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1264 if ( it != _nbddcs.end() )
1265 ret = it->second->setConfiguration(cfg);
1266 return ret;
1267 }
1268
1269 double RadioHandler::getNbddcFrequency(int index) const
1270 {
1271 double ret = 0.0;
1272 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1273 if ( it != _nbddcs.end() )
1274 ret = it->second->getFrequency();
1275 return ret;
1276 }
1277
1278 bool RadioHandler::setNbddcFrequency(int index, double freq)
1279 {
1280 bool ret = false;
1281 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1282 if ( it != _nbddcs.end() )
1283 ret = it->second->setFrequency(freq);
1284 return ret;
1285 }
1286
1287 int RadioHandler::getNbddcSource(int index) const
1288 {
1289 int ret = 0;
1290 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1291 if ( it != _nbddcs.end() )
1292 ret = it->second->getSource();
1293 return ret;
1294 }
1295
1296 bool RadioHandler::setNbddcSource(int index, int source)
1297 {
1298 bool ret = false;
1299 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1300 if ( it != _nbddcs.end() )
1301 ret = it->second->setSource(source);
1302 return ret;
1303 }
1304
1305 int RadioHandler::getNbddcRateIndex(int index) const
1306 {
1307 int ret = 0;
1308 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1309 if ( it != _nbddcs.end() )
1310 ret = it->second->getRateIndex();
1311 return ret;
1312 }
1313
1314 bool RadioHandler::setNbddcRateIndex(int index, int rateIndex)
1315 {
1316 bool ret = false;
1317 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1318 if ( it != _nbddcs.end() )
1319 ret = it->second->setRateIndex(rateIndex);
1320 return ret;
1321 }
1322
1323 int RadioHandler::getNbddcUdpDestination(int index) const
1324 {
1325 int ret = 0;
1326 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1327 if ( it != _nbddcs.end() )
1328 ret = it->second->getUdpDestination();
1329 return ret;
1330 }
1331
1332 bool RadioHandler::setNbddcUdpDestination(int index, int dest)
1333 {
1334 bool ret = false;
1335 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1336 if ( it != _nbddcs.end() )
1337 ret = it->second->setUdpDestination(dest);
1338 return ret;
1339 }
1340
1341 int RadioHandler::getNbddcVitaEnable(int index) const
1342 {
1343 int ret = 0;
1344 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1345 if ( it != _nbddcs.end() )
1346 ret = it->second->getVitaEnable();
1347 return ret;
1348 }
1349
1350 bool RadioHandler::setNbddcVitaEnable(int index, int enable)
1351 {
1352 bool ret = false;
1353 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1354 if ( it != _nbddcs.end() )
1355 ret = it->second->setVitaEnable(enable);
1356 return ret;
1357 }
1358
1359 unsigned int RadioHandler::getNbddcStreamId(int index) const
1360 {
1361 int ret = 0;
1362 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1363 if ( it != _nbddcs.end() )
1364 ret = it->second->getStreamId();
1365 return ret;
1366 }
1367
1368 bool RadioHandler::setNbddcStreamId(int index, unsigned int sid)
1369 {
1370 bool ret = false;
1371 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1372 if ( it != _nbddcs.end() )
1373 ret = it->second->setStreamId(sid);
1374 return ret;
1375 }
1376
1377 int RadioHandler::getNbddcDataPort(int index) const
1378 {
1379 int ret = 0;
1380 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1381 if ( it != _nbddcs.end() )
1382 ret = it->second->getDataPort();
1383 return ret;
1384 }
1385
1386 bool RadioHandler::setNbddcDataPort(int index, int port)
1387 {
1388 bool ret = false;
1389 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1390 if ( it != _nbddcs.end() )
1391 ret = it->second->setDataPort(port);
1392 return ret;
1393 }
1394
1395 bool RadioHandler::setNbddcRateSet(int index, const NbddcRateSet& set)
1396 {
1397 bool ret = false;
1398 NbddcComponentDict::const_iterator it = _nbddcs.begin();
1399 if ( it != _nbddcs.end() )
1400 ret = it->second->setRateSet(set);
1401 return ret;
1402 }
1403
1404 int RadioHandler::getNumTransmitters() const
1405 {
1406 return _numTransmitter;
1407 }
1408
1409 BasicIntList RadioHandler::getTransmitterIndexRange() const
1410 {
1411 BasicIntList ret;
1412 for (int num = _transmitterIndexBase; num < _transmitterIndexBase + _numTransmitter;
1413 num++)
1414 ret.push_back(num);
1415 return ret;
1416 }
1417
1418 BasicDoubleList RadioHandler::getTransmitterFrequencyRange() const
1419 {
1420 BasicDoubleList ret;
1421 TransmitterComponentDict::const_iterator it = _txs.begin();
1422 if ( it != _txs.end() )
1423 ret = it->second->getFrequencyRange();
1424 return ret;
1425 }
1426
1427 double RadioHandler::getTransmitterFrequencyRes() const
1428 {
1429 double ret = 0.0;
1430 TransmitterComponentDict::const_iterator it = _txs.begin();
1431 if ( it != _txs.end() )
1432 ret = it->second->getFrequencyRes();
1433 return ret;
1434 }
1435
1436 double RadioHandler::getTransmitterFrequencyUnit() const
1437 {
1438 double ret = 0.0;
1439 TransmitterComponentDict::const_iterator it = _txs.begin();
1440 if ( it != _txs.end() )
1441 ret = it->second->getFrequencyUnit();
1442 return ret;
1443 }
1444
1445 BasicDoubleList RadioHandler::getTransmitterAttenuationRange() const
1446 {
1447 BasicDoubleList ret;
1448 TransmitterComponentDict::const_iterator it = _txs.begin();
1449 if ( it != _txs.end() )
1450 ret = it->second->getAttenuationRange();
1451 return ret;
1452 }
1453
1454 double RadioHandler::getTransmitterAttenuationRes() const
1455 {
1456 double ret = 0.0;
1457 TransmitterComponentDict::const_iterator it = _txs.begin();
1458 if ( it != _txs.end() )
1459 ret = it->second->getAttenuationRes();
1460 return ret;
1461 }
1462
1463 bool RadioHandler::isTransmitterEnabled(int index) const
1464 {
1465 bool ret = false;
1466 TransmitterComponentDict::const_iterator it = _txs.find(index);
1467 if ( it != _txs.end() )
1468 ret = it->second->isEnabled();
1469 return ret;
1470 }
1471
1472 bool RadioHandler::enableTransmitter(int index, bool enabled)
1473 {
1474 bool ret = false;
1475 TransmitterComponentDict::const_iterator it = _txs.find(index);
1476 if ( it != _txs.end() )
1477 ret = it->second->enable(enabled);
1478 return ret;
1479 }
1480
1481 bool RadioHandler::disableTransmitter(int index)
1482 {
1483 return enableTransmitter(index, false);
1484 }
1485
1486 double RadioHandler::getTransmitterFrequency(int index) const
1487 {
1488 double ret = 0.0;
1489 TransmitterComponentDict::const_iterator it = _txs.find(index);
1490 if ( it != _txs.end() )
1491 ret = it->second->getFrequency();
1492 return ret;
1493 }
1494
1495 bool RadioHandler::setTransmitterFrequency(int index, double freq)
1496 {
1497 bool ret = false;
1498 TransmitterComponentDict::const_iterator it = _txs.find(index);
1499 if ( it != _txs.end() )
1500 ret = it->second->setFrequency(freq);
1501 return ret;
1502 }
1503
1504 double RadioHandler::getTransmitterAttenuation(int index) const
1505 {
1506 double ret = 0.0;
1507 TransmitterComponentDict::const_iterator it = _txs.find(index);
1508 if ( it != _txs.end() )
1509 ret = it->second->getAttenuation();
1510 return ret;
1511 }
1512
1513 bool RadioHandler::setTransmitterAttenuation(int index, double atten)
1514 {
1515 bool ret = false;
1516 TransmitterComponentDict::const_iterator it = _txs.find(index);
1517 if ( it != _txs.end() )
1518 ret = it->second->setAttenuation(atten);
1519 return ret;
1520 }
1521
1522 ConfigurationDict RadioHandler::getTransmitterConfiguration(int index) const
1523 {
1524 ConfigurationDict ret;
1525 TransmitterComponentDict::const_iterator it = _txs.find(index);
1526 if ( it != _txs.end() )
1527 ret = it->second->getConfiguration();
1528 return ret;
1529 }
1530
1531 bool RadioHandler::setTransmitterConfiguration(int index, ConfigurationDict& cfg)
1532 {
1533 bool ret = false;
1534 TransmitterComponentDict::const_iterator it = _txs.find(index);
1535 if ( it != _txs.end() )
1536 ret = it->second->setConfiguration(cfg);
1537 return ret;
1538 }
1539
1540 bool RadioHandler::transmitterSupportsCW() const
1541 {
1542 bool ret = false;
1543 TransmitterComponentDict::const_iterator it = _txs.begin();
1544 if ( it != _txs.end() )
1545 ret = it->second->supportsCW();
1546 return ret;
1547 }
1548
1549 int RadioHandler::getTransmitterCWNum() const
1550 {
1551 int ret = 0;
1552 TransmitterComponentDict::const_iterator it = _txs.begin();
1553 if ( it != _txs.end() )
1554 ret = it->second->getCWNum();
1555 return ret;
1556 }
1557
1558 BasicIntList RadioHandler::getTransmitterCWIndexRange() const
1559 {
1560 BasicIntList ret;
1561 TransmitterComponentDict::const_iterator it = _txs.begin();
1562 if ( it != _txs.end() )
1563 ret = it->second->getCWIndexRange();
1564 return ret;
1565 }
1566
1567 BasicDoubleList RadioHandler::getTransmitterCWFrequencyRange() const
1568 {
1569 BasicDoubleList ret;
1570 TransmitterComponentDict::const_iterator it = _txs.begin();
1571 if ( it != _txs.end() )
1572 ret = it->second->getCWFrequencyRange();
1573 return ret;
1574 }
1575
1576 double RadioHandler::getTransmitterCWFrequencyRes() const
1577 {
1578 double ret = 0.0;
1579 TransmitterComponentDict::const_iterator it = _txs.begin();
1580 if ( it != _txs.end() )
1581 ret = it->second->getCWFrequencyRes();
1582 return ret;
1583 }
1584
1585 BasicDoubleList RadioHandler::getTransmitterCWAmplitudeRange() const
1586 {
1587 BasicDoubleList ret;
1588 TransmitterComponentDict::const_iterator it = _txs.begin();
1589 if ( it != _txs.end() )
1590 ret = it->second->getCWAmplitudeRange();
1591 return ret;
1592 }
1593
1594 double RadioHandler::getTransmitterCWAmplitudeRes() const
1595 {
1596 double ret = 0.0;
1597 TransmitterComponentDict::const_iterator it = _txs.begin();
1598 if ( it != _txs.end() )
1599 ret = it->second->getCWAmplitudeRes();
1600 return ret;
1601 }
1602
1603 BasicDoubleList RadioHandler::getTransmitterCWPhaseRange() const
1604 {
1605 BasicDoubleList ret;
1606 TransmitterComponentDict::const_iterator it = _txs.begin();
1607 if ( it != _txs.end() )
1608 ret = it->second->getCWPhaseRange();
1609 return ret;
1610 }
1611
1612 int RadioHandler::getTransmitterCWPhaseRes() const
1613 {
1614 int ret = 0;
1615 TransmitterComponentDict::const_iterator it = _txs.begin();
1616 if ( it != _txs.end() )
1617 ret = it->second->getCWPhaseRes();
1618 return ret;
1619 }
1620
1621 bool RadioHandler::transmitterSupportsCWSweep() const
1622 {
1623 bool ret = false;
1624 TransmitterComponentDict::const_iterator it = _txs.begin();
1625 if ( it != _txs.end() )
1626 ret = it->second->supportsCWSweep();
1627 return ret;
1628 }
1629
1630 BasicDoubleList RadioHandler::getTransmitterCWSweepStartRange() const
1631 {
1632 BasicDoubleList ret;
1633 TransmitterComponentDict::const_iterator it = _txs.begin();
1634 if ( it != _txs.end() )
1635 ret = it->second->getCWSweepStartRange();
1636 return ret;
1637 }
1638
1639 double RadioHandler::getTransmitterCWSweepStartRes() const
1640 {
1641 double ret = 0.0;
1642 TransmitterComponentDict::const_iterator it = _txs.begin();
1643 if ( it != _txs.end() )
1644 ret = it->second->getCWSweepStartRes();
1645 return ret;
1646 }
1647
1648 BasicDoubleList RadioHandler::getTransmitterCWSweepStopRange() const
1649 {
1650 BasicDoubleList ret;
1651 TransmitterComponentDict::const_iterator it = _txs.begin();
1652 if ( it != _txs.end() )
1653 ret = it->second->getCWSweepStopRange();
1654 return ret;
1655 }
1656
1657 double RadioHandler::getTransmitterCWSweepStopRes() const
1658 {
1659 double ret = 0.0;
1660 TransmitterComponentDict::const_iterator it = _txs.begin();
1661 if ( it != _txs.end() )
1662 ret = it->second->getCWSweepStopRes();
1663 return ret;
1664 }
1665
1666 BasicDoubleList RadioHandler::getTransmitterCWSweepStepRange() const
1667 {
1668 BasicDoubleList ret;
1669 TransmitterComponentDict::const_iterator it = _txs.begin();
1670 if ( it != _txs.end() )
1671 ret = it->second->getCWSweepStepRange();
1672 return ret;
1673 }
1674
1675 double RadioHandler::getTransmitterCWSweepStepRes() const
1676 {
1677 double ret = 0.0;
1678 TransmitterComponentDict::const_iterator it = _txs.begin();
1679 if ( it != _txs.end() )
1680 ret = it->second->getCWSweepStepRes();
1681 return ret;
1682 }
1683
1684 BasicDoubleList RadioHandler::getTransmitterCWSweepDwellRange() const
1685 {
1686 BasicDoubleList ret;
1687 TransmitterComponentDict::const_iterator it = _txs.begin();
1688 if ( it != _txs.end() )
1689 ret = it->second->getCWSweepDwellRange();
1690 return ret;
1691 }
1692
1693 double RadioHandler::getTransmitterCWSweepDwellRes() const
1694 {
1695 double ret = 0.0;
1696 TransmitterComponentDict::const_iterator it = _txs.begin();
1697 if ( it != _txs.end() )
1698 ret = it->second->getCWSweepDwellRes();
1699 return ret;
1700 }
1701
1702 bool RadioHandler::enableTransmitterCW(int index, int cwIndex, bool enabled)
1703 {
1704 bool ret = false;
1705 TransmitterComponentDict::const_iterator it = _txs.find(index);
1706 if ( it != _txs.end() )
1707 ret = it->second->enableCW(cwIndex);
1708 return ret;
1709 }
1710
1711 bool RadioHandler::disableTransmitterCW(int index, int cwIndex)
1712 {
1713 return enableTransmitterCW(index, cwIndex, false);
1714 }
1715
1716 ConfigurationDict RadioHandler::getTransmitterCWConfiguration(int index,
1717 int cwIndex) const
1718 {
1719 ConfigurationDict ret;
1720 TransmitterComponentDict::const_iterator it = _txs.find(index);
1721 if ( it != _txs.end() )
1722 ret = it->second->getCWConfiguration(cwIndex);
1723 return ret;
1724 }
1725
1726 bool RadioHandler::setTransmitterCWConfiguration(int index, int cwIndex,
1727 ConfigurationDict& cfg)
1728 {
1729 bool ret = false;
1730 TransmitterComponentDict::const_iterator it = _txs.find(index);
1731 if ( it != _txs.end() )
1732 ret = it->second->setCWConfiguration(cwIndex, cfg);
1733 return ret;
1734 }
1735
1736 double RadioHandler::getTransmitterCWFrequency(int index, int cwIndex) const
1737 {
1738 double ret = 0.0;
1739 TransmitterComponentDict::const_iterator it = _txs.find(index);
1740 if ( it != _txs.end() )
1741 ret = it->second->getCWFrequency(cwIndex);
1742 return ret;
1743 }
1744
1745 bool RadioHandler::setTransmitterCWFrequency(int index, int cwIndex, double freq)
1746 {
1747 bool ret = false;
1748 TransmitterComponentDict::const_iterator it = _txs.find(index);
1749 if ( it != _txs.end() )
1750 ret = it->second->setCWFrequency(cwIndex, freq);
1751 return ret;
1752 }
1753
1754 double RadioHandler::getTransmitterCWAmplitude(int index, int cwIndex) const
1755 {
1756 double ret = 0.0;
1757 TransmitterComponentDict::const_iterator it = _txs.find(index);
1758 if ( it != _txs.end() )
1759 ret = it->second->getCWAmplitude(cwIndex);
1760 return ret;
1761 }
1762
1763 bool RadioHandler::setTransmitterCWAmplitude(int index, int cwIndex, double amp)
1764 {
1765 bool ret = false;
1766 TransmitterComponentDict::const_iterator it = _txs.find(index);
1767 if ( it != _txs.end() )
1768 ret = it->second->setCWAmplitude(cwIndex, amp);
1769 return ret;
1770 }
1771
1772 double RadioHandler::getTransmitterCWPhase(int index, int cwIndex) const
1773 {
1774 double ret = 0.0;
1775 TransmitterComponentDict::const_iterator it = _txs.find(index);
1776 if ( it != _txs.end() )
1777 ret = it->second->getCWPhase(cwIndex);
1778 return ret;
1779 }
1780
1781 bool RadioHandler::setTransmitterCWPhase(int index, int cwIndex, double phase)
1782 {
1783 bool ret = false;
1784 TransmitterComponentDict::const_iterator it = _txs.find(index);
1785 if ( it != _txs.end() )
1786 ret = it->second->setCWPhase(cwIndex, phase);
1787 return ret;
1788 }
1789
1790 bool RadioHandler::transmitterSupportsCWSweep(int index, int cwIndex) const
1791 {
1792 bool ret = false;
1793 TransmitterComponentDict::const_iterator it = _txs.find(index);
1794 if ( it != _txs.end() )
1795 ret = it->second->supportsCWSweep(cwIndex);
1796 return ret;
1797 }
1798
1799 double RadioHandler::getTransmitterCWSweepStartFrequency(int index, int cwIndex) const
1800 {
1801 double ret = 0.0;
1802 TransmitterComponentDict::const_iterator it = _txs.find(index);
1803 if ( it != _txs.end() )
1804 ret = it->second->getCWSweepStartFrequency(cwIndex);
1805 return ret;
1806 }
1807
1808 double RadioHandler::getTransmitterCWSweepStopFrequency(int index, int cwIndex) const
1809 {
1810 double ret = 0.0;
1811 TransmitterComponentDict::const_iterator it = _txs.find(index);
1812 if ( it != _txs.end() )
1813 ret = it->second->getCWSweepStopFrequency(cwIndex);
1814 return ret;
1815 }
1816
1817 double RadioHandler::getTransmitterCWSweepFrequencyStep(int index, int cwIndex) const
1818 {
1819 double ret = 0.0;
1820 TransmitterComponentDict::const_iterator it = _txs.find(index);
1821 if ( it != _txs.end() )
1822 ret = it->second->getCWSweepFrequencyStep(cwIndex);
1823 return ret;
1824 }
1825
1826 double RadioHandler::getTransmitterCWSweepDwellTime(int index, int cwIndex) const
1827 {
1828 double ret = 0.0;
1829 TransmitterComponentDict::const_iterator it = _txs.find(index);
1830 if ( it != _txs.end() )
1831 ret = it->second->getCWSweepDwellTime(cwIndex);
1832 return ret;
1833 }
1834
1835 bool RadioHandler::setTransmitterCWFrequencySweep(int index, int cwIndex, double start,
1836 double stop, double step, double dwell)
1837 {
1838 bool ret = false;
1839 TransmitterComponentDict::const_iterator it = _txs.find(index);
1840 if ( it != _txs.end() )
1841 ret = it->second->setCWFrequencySweep(cwIndex, start, stop, step, dwell);
1842 return ret;
1843 }
1844
1845 int RadioHandler::getNumDuc() const
1846 {
1847 return _numDuc;
1848 }
1849
1850 BasicIntList RadioHandler::getDucIndexRange() const
1851 {
1852 BasicIntList ret;
1853 for (int num = _ducIndexBase; num < _ducIndexBase + _numDuc; num++)
1854 ret.push_back(num);
1855 return ret;
1856 }
1857
1858 bool RadioHandler::ducSupportsSnapshotLoad() const
1859 {
1860 bool ret = false;
1861 DucComponentDict::const_iterator it = _ducs.begin();
1862 if ( it != _ducs.end() )
1863 ret = it->second->supportsSnapshotLoad();
1864 return ret;
1865 }
1866
1867 bool RadioHandler::ducSupportsSnapshotTransmit() const
1868 {
1869 bool ret = false;
1870 DucComponentDict::const_iterator it = _ducs.begin();
1871 if ( it != _ducs.end() )
1872 ret = it->second->supportsSnapshotTransmit();
1873 return ret;
1874 }
1875
1876 bool RadioHandler::enableDuc(int index, bool enabled)
1877 {
1878 bool ret = false;
1879 DucComponentDict::const_iterator it = _ducs.find(index);
1880 if ( it != _ducs.end() )
1881 ret = it->second->enable(enabled);
1882 return ret;
1883 }
1884
1885 bool RadioHandler::disableDuc(int index)
1886 {
1887 return enableDuc(index, false);
1888 }
1889
1890 ConfigurationDict RadioHandler::getDucConfiguration(int index) const
1891 {
1892 ConfigurationDict ret;
1893 DucComponentDict::const_iterator it = _ducs.find(index);
1894 if ( it != _ducs.end() )
1895 ret = it->second->getConfiguration();
1896 return ret;
1897 }
1898
1899 bool RadioHandler::setDucConfiguration(int index, ConfigurationDict& cfg)
1900 {
1901 bool ret = false;
1902 DucComponentDict::const_iterator it = _ducs.find(index);
1903 if ( it != _ducs.end() )
1904 ret = it->second->setConfiguration(cfg);
1905 return ret;
1906 }
1907
1908 int RadioHandler::getDucDataPort(int index) const
1909 {
1910 int ret = 0;
1911 DucComponentDict::const_iterator it = _ducs.find(index);
1912 if ( it != _ducs.end() )
1913 ret = it->second->getDataPort();
1914 return ret;
1915 }
1916
1917 bool RadioHandler::setDucDataPort(int index, int port)
1918 {
1919 bool ret = false;
1920 DucComponentDict::const_iterator it = _ducs.find(index);
1921 if ( it != _ducs.end() )
1922 ret = it->second->setDataPort(port);
1923 return ret;
1924 }
1925
1926 double RadioHandler::getDucFrequency(int index) const
1927 {
1928 double ret = 0.0;
1929 DucComponentDict::const_iterator it = _ducs.find(index);
1930 if ( it != _ducs.end() )
1931 ret = it->second->getFrequency();
1932 return ret;
1933 }
1934
1935 bool RadioHandler::setDucFrequency(int index, double freq)
1936 {
1937 bool ret = false;
1938 DucComponentDict::const_iterator it = _ducs.find(index);
1939 if ( it != _ducs.end() )
1940 ret = it->second->setFrequency(freq);
1941 return ret;
1942 }
1943
1944 BasicDoubleList RadioHandler::getDucFrequencyRange() const
1945 {
1946 BasicDoubleList ret;
1947 DucComponentDict::const_iterator it = _ducs.begin();
1948 if ( it != _ducs.end() )
1949 ret = it->second->getFrequencyRange();
1950 return ret;
1951 }
1952
1953 double RadioHandler::getDucFrequencyRes() const
1954 {
1955 double ret = 0.0;
1956 DucComponentDict::const_iterator it = _ducs.begin();
1957 if ( it != _ducs.end() )
1958 ret = it->second->getFrequencyRes();
1959 return ret;
1960 }
1961
1962 double RadioHandler::getDucFrequencyUnit() const
1963 {
1964 double ret = 0.0;
1965 DucComponentDict::const_iterator it = _ducs.begin();
1966 if ( it != _ducs.end() )
1967 ret = it->second->getFrequencyUnit();
1968 return ret;
1969 }
1970
1971 double RadioHandler::getDucAttenuation(int index) const
1972 {
1973 double ret = 0.0;
1974 DucComponentDict::const_iterator it = _ducs.find(index);
1975 if ( it != _ducs.end() )
1976 ret = it->second->getAttenuation();
1977 return ret;
1978 }
1979
1980 bool RadioHandler::setDucAttenuation(int index, double atten)
1981 {
1982 bool ret = false;
1983 DucComponentDict::const_iterator it = _ducs.find(index);
1984 if ( it != _ducs.end() )
1985 ret = it->second->setAttenuation(atten);
1986 return ret;
1987 }
1988
1989 BasicDoubleList RadioHandler::getDucAttenuationRange() const
1990 {
1991 BasicDoubleList ret;
1992 DucComponentDict::const_iterator it = _ducs.begin();
1993 if ( it != _ducs.end() )
1994 ret = it->second->getAttenuationRange();
1995 return ret;
1996 }
1997
1998 double RadioHandler::getDucAttenuationRes() const
1999 {
2000 double ret = 0.0;
2001 DucComponentDict::const_iterator it = _ducs.begin();
2002 if ( it != _ducs.end() )
2003 ret = it->second->getAttenuationRes();
2004 return ret;
2005 }
2006
2007 int RadioHandler::getDucRateIndex(int index) const
2008 {
2009 int ret = 0;
2010 DucComponentDict::const_iterator it = _ducs.find(index);
2011 if ( it != _ducs.end() )
2012 ret = it->second->getRateIndex();
2013 return ret;
2014 }
2015
2016 bool RadioHandler::setDucRateIndex(int index, int rateIndex)
2017 {
2018 bool ret = false;
2019 DucComponentDict::const_iterator it = _ducs.find(index);
2020 if ( it != _ducs.end() )
2021 ret = it->second->setRateIndex(rateIndex);
2022 return ret;
2023 }
2024
2025 int RadioHandler::getDucTxChannelBitmap(int index) const
2026 {
2027 int ret = 0;
2028 DucComponentDict::const_iterator it = _ducs.find(index);
2029 if ( it != _ducs.end() )
2030 ret = it->second->getTxChannelBitmap();
2031 return ret;
2032 }
2033
2034 bool RadioHandler::setDucTxChannelBitmap(int index, int txChannels)
2035 {
2036 bool ret = false;
2037 DucComponentDict::const_iterator it = _ducs.find(index);
2038 if ( it != _ducs.end() )
2039 ret = it->second->setTxChannelBitmap(txChannels);
2040 return ret;
2041 }
2042
2043 int RadioHandler::getDucMode(int index) const
2044 {
2045 int ret = 0;
2046 DucComponentDict::const_iterator it = _ducs.find(index);
2047 if ( it != _ducs.end() )
2048 ret = it->second->getMode();
2049 return ret;
2050 }
2051
2052 bool RadioHandler::setDucMode(int index, int mode)
2053 {
2054 bool ret = false;
2055 DucComponentDict::const_iterator it = _ducs.find(index);
2056 if ( it != _ducs.end() )
2057 ret = it->second->setMode(mode);
2058 return ret;
2059 }
2060
2061 unsigned int RadioHandler::getDucStreamId(int index) const
2062 {
2063 int ret = 0;
2064 DucComponentDict::const_iterator it = _ducs.find(index);
2065 if ( it != _ducs.end() )
2066 ret = it->second->getStreamId();
2067 return ret;
2068 }
2069
2070 bool RadioHandler::setDucStreamId(int index, unsigned int sid)
2071 {
2072 bool ret = false;
2073 DucComponentDict::const_iterator it = _ducs.find(index);
2074 if ( it != _ducs.end() )
2075 ret = it->second->setStreamId(sid);
2076 return ret;
2077 }
2078
2079 bool RadioHandler::loadDucSnapshot(int index,
2080 const std::string& filename,
2081 unsigned int startSample,
2082 unsigned int samples)
2083 {
2084 bool ret = false;
2085 DucComponentDict::const_iterator it = _ducs.find(index);
2086 if ( it != _ducs.end() )
2087 if ( it->second->supportsSnapshotLoad() )
2088 ret = it->second->loadSnapshot(filename, startSample, samples);
2089 return ret;
2090 }
2091
2092 DucRateSet RadioHandler::getDucRateSet() const
2093 {
2094 DucRateSet ret;
2095 DucComponentDict::const_iterator it = _ducs.begin();
2096 if ( it != _ducs.end() )
2097 ret = it->second->getRateSet();
2098 return ret;
2099 }
2100
2101 BasicDoubleList RadioHandler::getDucRateList() const
2102 {
2103 BasicDoubleList ret;
2104 DucComponentDict::const_iterator it = _ducs.begin();
2105 if ( it != _ducs.end() )
2106 ret = it->second->getRateList();
2107 return ret;
2108 }
2109
2110 int RadioHandler::getNumWbddcGroups() const
2111 {
2112 return _numWbddcGroups;
2113 }
2114
2115 BasicIntList RadioHandler::getWbddcGroupIndexRange() const
2116 {
2117 BasicIntList ret;
2118 for (int num = _wbddcGroupIndexBase; num < _wbddcGroupIndexBase + _numWbddcGroups; num++)
2119 ret.push_back(num);
2120 return ret;
2121 }
2122
2123 bool RadioHandler::isWbddcGroupEnabled(int index) const
2124 {
2125 bool ret = false;
2126 WbddcGroupComponentDict::const_iterator it = _wbddcGroups.find(index);
2127 if ( it != _wbddcGroups.end() )
2128 ret = it->second->isEnabled();
2129 return ret;
2130 }
2131
2132 bool RadioHandler::enableWbddcGroup(int index, bool enabled)
2133 {
2134 bool ret = false;
2135 WbddcGroupComponentDict::const_iterator it = _wbddcGroups.find(index);
2136 if ( it != _wbddcGroups.end() )
2137 ret = it->second->enable(enabled);
2138 return ret;
2139 }
2140
2141 bool RadioHandler::disableWbddcGroup(int index)
2142 {
2143 return enableWbddcGroup(index, false);
2144 }
2145
2146 ConfigurationDict RadioHandler::getWbddcGroupConfiguration(int index) const
2147 {
2148 ConfigurationDict ret;
2149 WbddcGroupComponentDict::const_iterator it = _wbddcGroups.find(index);
2150 if ( it != _wbddcGroups.end() )
2151 ret = it->second->getConfiguration();
2152 return ret;
2153 }
2154
2155 bool RadioHandler::setWbddcGroupConfiguration(int index, ConfigurationDict& cfg)
2156 {
2157 bool ret = false;
2158 WbddcGroupComponentDict::const_iterator it = _wbddcGroups.find(index);
2159 if ( it != _wbddcGroups.end() )
2160 ret = it->second->setConfiguration(cfg);
2161 return ret;
2162 }
2163
2164 BasicIntList RadioHandler::getWbddcGroupMembers(int index) const
2165 {
2166 BasicIntList ret;
2167 WbddcGroupComponentDict::const_iterator it = _wbddcGroups.find(index);
2168 if ( it != _wbddcGroups.end() )
2169 ret = it->second->getMembers();
2170 return ret;
2171 }
2172
2173 bool RadioHandler::setWbddcGroupMembers(int index, const BasicIntList& groupMembers)
2174 {
2175 bool ret = false;
2176 WbddcGroupComponentDict::const_iterator it = _wbddcGroups.find(index);
2177 if ( it != _wbddcGroups.end() )
2178 ret = it->second->setMembers(groupMembers);
2179 return ret;
2180 }
2181
2182 bool RadioHandler::addWbddcGroupMember(int index, int member)
2183 {
2184 bool ret = false;
2185 WbddcGroupComponentDict::const_iterator it = _wbddcGroups.find(index);
2186 if ( it != _wbddcGroups.end() )
2187 ret = it->second->addMember(member);
2188 return ret;
2189 }
2190
2191 bool RadioHandler::removeWbddcGroupMember(int index, int member)
2192 {
2193 bool ret = false;
2194 WbddcGroupComponentDict::const_iterator it = _wbddcGroups.find(index);
2195 if ( it != _wbddcGroups.end() )
2196 ret = it->second->removeMember(member);
2197 return ret;
2198 }
2199
2200 int RadioHandler::getNumNbddcGroups() const
2201 {
2202 return _numNbddcGroups;
2203 }
2204
2205 BasicIntList RadioHandler::getNbddcGroupIndexRange() const
2206 {
2207 BasicIntList ret;
2208 for (int num = _nbddcGroupIndexBase; num < _nbddcGroupIndexBase + _numNbddcGroups; num++)
2209 ret.push_back(num);
2210 return ret;
2211 }
2212
2213 bool RadioHandler::isNbddcGroupEnabled(int index) const
2214 {
2215 bool ret = false;
2216 NbddcGroupComponentDict::const_iterator it = _nbddcGroups.find(index);
2217 if ( it != _nbddcGroups.end() )
2218 ret = it->second->isEnabled();
2219 return ret;
2220 }
2221
2222 bool RadioHandler::enableNbddcGroup(int index, bool enabled)
2223 {
2224 bool ret = false;
2225 NbddcGroupComponentDict::const_iterator it = _nbddcGroups.find(index);
2226 if ( it != _nbddcGroups.end() )
2227 ret = it->second->enable(enabled);
2228 return ret;
2229 }
2230
2231 bool RadioHandler::disableNbddcGroup(int index)
2232 {
2233 return enableNbddcGroup(index, false);
2234 }
2235
2236 ConfigurationDict RadioHandler::getNbddcGroupConfiguration(int index) const
2237 {
2238 ConfigurationDict ret;
2239 NbddcGroupComponentDict::const_iterator it = _nbddcGroups.find(index);
2240 if ( it != _nbddcGroups.end() )
2241 ret = it->second->getConfiguration();
2242 return ret;
2243 }
2244
2245 bool RadioHandler::setNbddcGroupConfiguration(int index, ConfigurationDict& cfg)
2246 {
2247 bool ret = false;
2248 NbddcGroupComponentDict::const_iterator it = _nbddcGroups.find(index);
2249 if ( it != _nbddcGroups.end() )
2250 ret = it->second->setConfiguration(cfg);
2251 return ret;
2252 }
2253
2254 BasicIntList RadioHandler::getNbddcGroupMembers(int index) const
2255 {
2256 BasicIntList ret;
2257 NbddcGroupComponentDict::const_iterator it = _nbddcGroups.find(index);
2258 if ( it != _nbddcGroups.end() )
2259 ret = it->second->getMembers();
2260 return ret;
2261 }
2262
2263 bool RadioHandler::setNbddcGroupMembers(int index, const BasicIntList& groupMembers)
2264 {
2265 bool ret = false;
2266 NbddcGroupComponentDict::const_iterator it = _nbddcGroups.find(index);
2267 if ( it != _nbddcGroups.end() )
2268 ret = it->second->setMembers(groupMembers);
2269 return ret;
2270 }
2271
2272 bool RadioHandler::addNbddcGroupMember(int index, int member)
2273 {
2274 bool ret = false;
2275 NbddcGroupComponentDict::const_iterator it = _nbddcGroups.find(index);
2276 if ( it != _nbddcGroups.end() )
2277 ret = it->second->addMember(member);
2278 return ret;
2279 }
2280
2281 bool RadioHandler::removeNbddcGroupMember(int index, int member)
2282 {
2283 bool ret = false;
2284 NbddcGroupComponentDict::const_iterator it = _nbddcGroups.find(index);
2285 if ( it != _nbddcGroups.end() )
2286 ret = it->second->removeMember(member);
2287 return ret;
2288 }
2289
2294
2299
2300 bool RadioHandler::setTenGigFlowControlStatus(bool enable)
2301 {
2302 bool ret = true;
2303 for ( DataPortDict::const_iterator it = _dataPorts.begin();
2304 it != _dataPorts.end(); it++)
2305 {
2306 ret &= it->second->enableFlowControl(enable);
2307 }
2308 return ret;
2309 }
2310
2311 BasicIntBoolDict RadioHandler::getTenGigFlowControlStatus()
2312 {
2313 BasicIntBoolDict ret;
2314 bool enabled;
2315 for ( DataPortDict::iterator it = _dataPorts.begin();
2316 it != _dataPorts.end(); it++)
2317 {
2318 ret[it->first] = it->second->getConfigurationValueAsBool("flowControl");
2319 }
2320 return ret;
2321 }
2322
2323 ConfigurationDict RadioHandler::getDataPortConfiguration(int index) const
2324 {
2325 ConfigurationDict ret;
2326 DataPortDict::const_iterator it = _dataPorts.find(index);
2327 if ( it != _dataPorts.end() )
2328 ret = it->second->getConfiguration();
2329 return ret;
2330 }
2331
2332 bool RadioHandler::setDataPortConfiguration(int index, ConfigurationDict& cfg)
2333 {
2334 bool ret = false;
2335 DataPortDict::const_iterator it = _dataPorts.find(index);
2336 if ( it != _dataPorts.end() )
2337 ret = it->second->setConfiguration(cfg);
2338 return ret;
2339 }
2340
2341 std::string RadioHandler::getDataPortSourceIP(int index) const
2342 {
2343 std::string ret = "";
2344 DataPortDict::const_iterator it = _dataPorts.find(index);
2345 if ( it != _dataPorts.end() )
2346 ret = it->second->getSourceIP();
2347 return ret;
2348 }
2349
2350 bool RadioHandler::setDataPortSourceIP(int index, const std::string& ipAddr)
2351 {
2352 bool ret = false;
2353 DataPortDict::const_iterator it = _dataPorts.find(index);
2354 if ( it != _dataPorts.end() )
2355 ret = it->second->setSourceIP(ipAddr);
2356 return ret;
2357 }
2358
2359 bool RadioHandler::enableDataPortErrors(int index, bool enabled)
2360 {
2361 bool ret = false;
2362 DataPortDict::const_iterator it = _dataPorts.find(index);
2363 if ( it != _dataPorts.end() )
2364 ret = it->second->enableErrors(enabled);
2365 return ret;
2366 }
2367
2368 bool RadioHandler::disableDataPortErrors(int index)
2369 {
2370 return enableDataPortErrors(index, false);
2371 }
2372
2373 bool RadioHandler::enableDataPortFlowControl(int index, bool enabled)
2374 {
2375 bool ret = false;
2376 DataPortDict::const_iterator it = _dataPorts.find(index);
2377 if ( it != _dataPorts.end() )
2378 ret = it->second->enableFlowControl(enabled);
2379 return ret;
2380 }
2381
2382 bool RadioHandler::disableDataPortFlowControl(int index)
2383 {
2384 return enableDataPortFlowControl(index, false);
2385 }
2386
2387 std::string RadioHandler::getDataPortDestMACAddress(int index, int dipIndex) const
2388 {
2389 std::string ret = "";
2390 DataPortDict::const_iterator it = _dataPorts.find(index);
2391 if ( it != _dataPorts.end() )
2392 ret = it->second->getDestMACAddress(dipIndex);
2393 return ret;
2394 }
2395
2396 bool RadioHandler::setDataPortDestMACAddress(int index, int dipIndex,
2397 const std::string& macAddr)
2398 {
2399 bool ret = false;
2400 DataPortDict::const_iterator it = _dataPorts.find(index);
2401 if ( it != _dataPorts.end() )
2402 ret = it->second->setDestMACAddress(dipIndex, macAddr);
2403 return ret;
2404 }
2405
2406 std::string RadioHandler::getDataPortDestIPAddress(int index, int dipIndex) const
2407 {
2408 std::string ret = "";
2409 DataPortDict::const_iterator it = _dataPorts.find(index);
2410 if ( it != _dataPorts.end() )
2411 ret = it->second->getDestIPAddress(dipIndex);
2412 return ret;
2413 }
2414
2415 bool RadioHandler::setDataPortDestIPAddress(int index, int dipIndex,
2416 const std::string& ipAddr)
2417 {
2418 bool ret = false;
2419 DataPortDict::const_iterator it = _dataPorts.find(index);
2420 if ( it != _dataPorts.end() )
2421 ret = it->second->setDestIPAddress(dipIndex, ipAddr);
2422 return ret;
2423 }
2424
2425 unsigned int RadioHandler::getDataPortDestSourcePort(int index, int dipIndex) const
2426 {
2427 unsigned int ret = 0;
2428 DataPortDict::const_iterator it = _dataPorts.find(index);
2429 if ( it != _dataPorts.end() )
2430 ret = it->second->getDestSourcePort(dipIndex);
2431 return ret;
2432 }
2433
2434 bool RadioHandler::setDataPortDestSourcePort(int index, int dipIndex,
2435 unsigned int sourcePort)
2436 {
2437 bool ret = false;
2438 DataPortDict::const_iterator it = _dataPorts.find(index);
2439 if ( it != _dataPorts.end() )
2440 ret = it->second->setDestSourcePort(dipIndex, sourcePort);
2441 return ret;
2442 }
2443
2444 unsigned int RadioHandler::getDataPortDestDestPort(int index, int dipIndex) const
2445 {
2446 unsigned int ret = 0;
2447 DataPortDict::const_iterator it = _dataPorts.find(index);
2448 if ( it != _dataPorts.end() )
2449 ret = it->second->getDestDestPort(dipIndex);
2450 return ret;
2451 }
2452
2453 bool RadioHandler::setDataPortDestDestPort(int index, int dipIndex,
2454 unsigned int destPort)
2455 {
2456 bool ret = false;
2457 DataPortDict::const_iterator it = _dataPorts.find(index);
2458 if ( it != _dataPorts.end() )
2459 ret = it->second->setDestDestPort(dipIndex, destPort);
2460 return ret;
2461 }
2462
2463 bool RadioHandler::setDataPortDestInfo(int index,
2464 int dipIndex,
2465 const std::string& ipAddr,
2466 const std::string& macAddr,
2467 unsigned int sourcePort,
2468 unsigned int destPort)
2469 {
2470 bool ret = false;
2471 DataPortDict::const_iterator it = _dataPorts.find(index);
2472 if ( it != _dataPorts.end() )
2473 ret = it->second->setDestInfo(dipIndex, ipAddr, macAddr, sourcePort,
2474 destPort);
2475 return ret;
2476 }
2477
2478 ConfigurationDict RadioHandler::getSimpleIPConfiguration() const
2479 {
2480 ConfigurationDict ret;
2481 if ( _numSimpleIpSetups > 0 )
2482 {
2483 ret = _simpleIpSetups.at(0)->getConfiguration();
2484 }
2485 return ret;
2486 }
2487
2488 bool RadioHandler::setSimpleIPConfiguration(ConfigurationDict& cfg)
2489 {
2490 bool ret = false;
2491 if ( _numSimpleIpSetups > 0 )
2492 {
2493 ret = _simpleIpSetups.at(0)->setConfiguration(cfg);
2494 }
2495 return ret;
2496 }
2497
2498 std::string RadioHandler::getSimpleSourceMACAddress() const
2499 {
2500 std::string ret = "";
2501 return ret;
2502 }
2503
2504 std::string RadioHandler::getSimpleSourceIPAddress() const
2505 {
2506 std::string ret = "";
2507 return ret;
2508 }
2509
2510 bool RadioHandler::setSimpleSourceIPAddress(const std::string& ipAddr)
2511 {
2512 bool ret = true;
2513 return ret;
2514 }
2515
2516 std::string RadioHandler::getSimpleDestMACAddress() const
2517 {
2518 std::string ret = "";
2519 return ret;
2520 }
2521
2522 bool RadioHandler::setSimpleDestMACAddress(const std::string& macAddr)
2523 {
2524 bool ret = true;
2525 return ret;
2526 }
2527
2528 std::string RadioHandler::getSimpleDestIPAddress() const
2529 {
2530 std::string ret = "";
2531 return ret;
2532 }
2533
2534 bool RadioHandler::setSimpleDestIPAddress(const std::string& ipAddr)
2535 {
2536 bool ret = true;
2537 return ret;
2538 }
2539
2540 int RadioHandler::getDefaultDeviceInfo() const
2541 {
2542 return _defaultDeviceInfo;
2543 }
2544
2545 // Default implementation is the NDR308 pattern
2546 void RadioHandler::initConfigurationDict()
2547 {
2548 //this->debug("[RadioHandler::initConfigurationDict] Called\n");
2549 _config.clear();
2550 _config["calibFrequency"] = _calibFrequency;
2551 _config["coherentMode"] = _coherentMode;
2552 _config["configMode"] = _configMode;
2553 _config["referenceMode"] = _referenceMode;
2554 _config["bypassMode"] = _referenceBypass;
2555 _config["freqNormalization"] = _freqNormalization;
2556 _config["gpsEnable"] = _gpsEnabled;
2557 _config["referenceTuningVoltage"] = _referenceTuningVoltage;
2558 //this->debug("[RadioHandler::initConfigurationDict] Returning\n");
2559 }
2560
2561 void RadioHandler::updateConfigurationDict()
2562 {
2563 //this->debug("[RadioHandler::updateConfigurationDict] Called\n");
2564 if ( _config.hasKey("configMode") )
2565 {
2566 _config["configMode"] = _configMode;
2567 }
2568 if ( _config.hasKey("coherentMode") )
2569 {
2570 _config["coherentMode"] = _coherentMode;
2571 }
2572 if ( _config.hasKey("freqNormalization") )
2573 {
2574 _config["freqNormalization"] = _freqNormalization;
2575 }
2576 if ( _config.hasKey("gpsEnable") )
2577 {
2578 _config["gpsEnable"] = _gpsEnabled;
2579 }
2580 if ( _config.hasKey("referenceMode") )
2581 {
2582 _config["referenceMode"] = _referenceMode;
2583 }
2584 if ( _config.hasKey("bypassMode") )
2585 {
2586 _config["bypassMode"] = _referenceBypass;
2587 }
2588 if ( _config.hasKey("referenceTuningVoltage") )
2589 {
2590 _config["referenceTuningVoltage"] = _referenceTuningVoltage;
2591 }
2592 if ( _config.hasKey("calibFrequency") )
2593 {
2594 _config["calibFrequency"] = _calibFrequency;
2595 }
2596 //this->debug("[RadioHandler::updateConfigurationDict] Returning\n");
2597 }
2598
2599 bool RadioHandler::queryVersionInfo()
2600 {
2601 this->debug("[RadioHandler::queryVersionInfo] Called\n");
2602 bool ret = executeQueryIDN(_versionInfo["model"], _versionInfo["serialNumber"]);
2603 if (ret)
2604 {
2605 ret = executeQueryVER(_versionInfo["softwareVersion"],
2606 _versionInfo["firmwareVersion"],
2607 _versionInfo["referenceVersion"],
2608 _versionInfo["firmwareDate"] );
2609 if ( ret )
2610 {
2611 ret = executeQueryHREV(_versionInfo["hardwareVersion"]);
2612 }
2613 }
2614 this->debug("[RadioHandler::queryVersionInfo] Returning %s\n", debugBool(ret));
2615 if (ret)
2616 {
2617 for (BasicStringStringDict::iterator it = _versionInfo.begin(); it != _versionInfo.end(); it++)
2618 {
2619 this->debug("[RadioHandler::queryVersionInfo] %s = \"%s\"\n", it->first.c_str(), it->second.c_str());
2620 }
2621 }
2622 return ret;
2623 }
2624
2625 bool RadioHandler::queryRadioConfiguration()
2626 {
2627 bool ret = true;
2628 if ( _config.hasKey("configMode") )
2629 {
2630 ret &= this->executeConfigModeQuery(_configMode);
2631 }
2632 if ( _config.hasKey("coherentMode") )
2633 {
2634 ret &= this->executeCoherentModeQuery(_coherentMode);
2635 }
2636 if ( _config.hasKey("freqNormalization") )
2637 {
2638 ret &= this->executeFreqNormalizationQuery(_freqNormalization);
2639 }
2640 if ( _config.hasKey("gpsEnable") )
2641 {
2642 ret &= this->executeGpsEnabledQuery(_gpsEnabled);
2643 }
2644 if ( _config.hasKey("referenceMode") )
2645 {
2646 ret &= this->executeReferenceModeQuery(_referenceMode);
2647 }
2648 if ( _config.hasKey("bypassMode") )
2649 {
2650 ret &= this->executeReferenceBypassQuery(_referenceBypass);
2651 }
2652 if ( _config.hasKey("referenceTuningVoltage") )
2653 {
2654 ret &= this->executeReferenceVoltageQuery(_referenceTuningVoltage);
2655 }
2656 if ( _config.hasKey("calibFrequency") )
2657 {
2658 ret &= this->executeCalibFrequencyQuery(_calibFrequency);
2659 }
2660 return ret;
2661 }
2662
2663 // NOTE: Default implementation is based on the NDR308 response
2664 // NDR308 Receiver
2665 // S/N 2038
2666 // OK
2667 bool RadioHandler::executeQueryIDN(std::string& model,
2668 std::string& serialNumber)
2669 {
2670 bool ret = false;
2671 // Issue the identity query to get model and serial number
2672 BasicStringList rsp = sendCommand("*IDN?\n", _defaultTimeout);
2673 if ( getLastCommandErrorInfo() == "" )
2674 {
2675 BasicStringList::iterator it;
2676 for (it = rsp.begin(); it != rsp.end(); it++)
2677 {
2678 if ( it->find(" Receiver") != std::string::npos )
2679 model = Pythonesque::Replace(*it, " Receiver", "");
2680 else if ( it->find("NDR") != std::string::npos )
2681 model = *it;
2682 if ( it->find("S/N ") != std::string::npos )
2683 serialNumber = Pythonesque::Replace(*it, "S/N ", "");
2684 }
2685 ret = true;
2686 }
2687 return ret;
2688 }
2689
2690 // NOTE: Default implementation is based on the NDR308 response
2691 // NDR308 Application code:
2692 // REV: 16.02.16
2693 // Date: Feb 16 2016 13:59:48
2694 // FPGA Rev: 20150923
2695 // NDR308 Digital Reference Code Version: 16.01.21
2696 // OK
2697 bool RadioHandler::executeQueryVER(std::string& softwareVersion,
2698 std::string& firmwareVersion,
2699 std::string& referenceVersion,
2700 std::string& firmwareDate)
2701 {
2702 bool ret = true;
2703 // Query the version command to get software versioning info
2704 BasicStringList rsp = sendCommand("VER?\n", _defaultTimeout);
2705 if ( getLastCommandErrorInfo() == "" )
2706 {
2707 BasicStringList::iterator it;
2708 for (it = rsp.begin(); it != rsp.end(); it++)
2709 {
2710 if ( it->find(" REV: ") != std::string::npos )
2711 softwareVersion = Pythonesque::Replace(*it, " REV: ", "");
2712 if ( it->find(" Date: ") != std::string::npos )
2713 firmwareDate = Pythonesque::Replace(*it, " Date: ", "");
2714 if ( it->find("FPGA Rev: ") != std::string::npos )
2715 firmwareVersion = Pythonesque::Replace(*it, "FPGA Rev: ", "");
2716 std::string::size_type pos = it->find("Digital Reference Code Version: ");
2717 if ( pos != std::string::npos )
2718 referenceVersion = it->substr(pos+32, std::string::npos);
2719 }
2720 ret = true;
2721 }
2722 return ret;
2723 }
2724
2725 // NOTE: Default implementation is based on the NDR308 response
2726 // Unit
2727 // Model: NDR308 Receiver
2728 // Serial: 2038
2729 // Revision: 04.00
2730 // Digital Board_tuners
2731 // Model: 602851
2732 // Serial: 51150004
2733 // Revision: 05.00
2734 // Tuner Quad 1:
2735 // Board Model : 603056
2736 // Board Revision: 04.00
2737 // Serial Number : IE7210015
2738 // Bandwidth: 6000
2739 // Tuner Quad 2:Not Installed
2740 bool RadioHandler::executeQueryHREV(std::string& hardwareInfo)
2741 {
2742 bool ret = true;
2743 // Query the hardware revision command to get other stuff
2744 BasicStringList rsp = sendCommand("HREV?\n", _defaultTimeout);
2745 if ( getLastCommandErrorInfo() == "" )
2746 {
2747 std::ostringstream oss;
2748 BasicStringList::iterator it;
2749 for (it = rsp.begin(); it != rsp.end(); it++)
2750 {
2751 if ( *it != "OK" )
2752 {
2753 if ( oss.str() != "" )
2754 oss << "\n";
2755 //oss << Pythonesque::Strip(*it);
2756 oss << *it;
2757 }
2758 }
2759 hardwareInfo = oss.str();
2760 ret = true;
2761 }
2762 return ret;
2763 }
2764
2765 // NOTE: Default implementation is based on the NDR308 response
2766 // (a radio that doesn't actually support this command)
2767 bool RadioHandler::executeResetCommand(int resetType)
2768 {
2769 bool ret = false;
2770 return ret;
2771 }
2772
2773 // NOTE: Default implementation is based on the NDR308 response
2774 bool RadioHandler::executePpsQuery()
2775 {
2776 bool ret = false;
2777 // Query the PPS
2778 BasicStringList rsp = sendCommand("PPS?\n", _defaultTimeout);
2779 if ( getLastCommandErrorInfo() == "" )
2780 {
2781 ret = true;
2782 }
2783 return ret;
2784 }
2785
2786 // NOTE: Default implementation is based on the NDR308 response
2787 bool RadioHandler::executeTimeQuery(std::string& timeStr)
2788 {
2789 bool ret = false;
2790 // Query the time
2791 BasicStringList rsp = sendCommand("UTC?\n", _defaultTimeout);
2792 if ( getLastCommandErrorInfo() == "" )
2793 {
2794 BasicStringList::iterator it;
2795 for (it = rsp.begin(); it != rsp.end(); it++)
2796 {
2797 if ( it->find("UTC ") != std::string::npos )
2798 timeStr = Pythonesque::Replace(*it, "UTC ", "");
2799 }
2800 ret = true;
2801 }
2802 return ret;
2803 }
2804
2805 // NOTE: Default implementation is based on the NDR308 response
2806 bool RadioHandler::executeTimeCommand(std::string& timeStr)
2807 {
2808 bool ret = false;
2809 // Query the time
2810 BasicStringList rsp = sendCommand("UTC?\n", _defaultTimeout);
2811 if ( getLastCommandErrorInfo() == "" )
2812 {
2813 BasicStringList::iterator it;
2814 for (it = rsp.begin(); it != rsp.end(); it++)
2815 {
2816 if ( it->find("UTC ") != std::string::npos )
2817 timeStr = Pythonesque::Replace(*it, "UTC ", "");
2818 }
2819 ret = true;
2820 }
2821 return ret;
2822 }
2823
2824 // NOTE: Default implementation is based on the NDR308 response
2825 bool RadioHandler::executeGpsTimeQuery(std::string& timeStr)
2826 {
2827 bool ret = false;
2828 // Query the time
2829 BasicStringList rsp = sendCommand("GUTC?\n", _defaultTimeout);
2830 if ( getLastCommandErrorInfo() == "" )
2831 {
2832 BasicStringList::iterator it;
2833 for (it = rsp.begin(); it != rsp.end(); it++)
2834 {
2835 if ( it->find("GUTC ") != std::string::npos )
2836 timeStr = Pythonesque::Replace(*it, "GUTC ", "");
2837 }
2838 ret = true;
2839 }
2840 return ret;
2841 }
2842
2843 bool RadioHandler::executeConfigModeQuery(int& configMode)
2844 {
2845 this->debug("[RadioHandler::executeConfigModeQuery] Called\n");
2846 bool ret = false;
2847 if ( this->isConnected() )
2848 {
2849 std::ostringstream oss;
2850 oss << "CFG?" << "\n";
2851 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
2852 if ( this->getLastCommandErrorInfo() == "" )
2853 {
2854 BasicStringList vec = Pythonesque::Split(
2855 Pythonesque::Replace(rsp.front(), "CFG ", ""),
2856 ", ");
2857 // vec[0] = Config mode indicator
2858 configMode = boost::lexical_cast<int>(vec[0]);
2859 ret = true;
2860 }
2861 }
2862 this->debug("[RadioHandler::executeConfigModeQuery] Returning %s\n",
2863 this->debugBool(ret));
2864 return ret;
2865 }
2866
2867 bool RadioHandler::executeConfigModeCommand(int& configMode)
2868 {
2869 this->debug("[RadioHandler::executeConfigModeCommand] Called\n");
2870 bool ret = false;
2871 if ( this->isConnected() )
2872 {
2873 std::ostringstream oss;
2874 oss << "CFG " << configMode << "\n";
2875 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
2876 if ( this->getLastCommandErrorInfo() == "" )
2877 {
2878 ret = true;
2879 }
2880 }
2881 this->debug("[RadioHandler::executeConfigModeCommand] Returning %s\n",
2882 this->debugBool(ret));
2883 return ret;
2884 }
2885
2886 bool RadioHandler::executeCoherentModeQuery(int& coherentMode)
2887 {
2888 this->debug("[RadioHandler::executeCoherentModeQuery] Called\n");
2889 bool ret = false;
2890 if ( this->isConnected() )
2891 {
2892 std::ostringstream oss;
2893 oss << "COH?" << "\n";
2894 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
2895 if ( this->getLastCommandErrorInfo() == "" )
2896 {
2897 BasicStringList vec = Pythonesque::Split(
2898 Pythonesque::Replace(rsp.front(), "COH ", ""),
2899 ", ");
2900 // vec[0] = Coherent mode indicator
2901 // NOTE: This is a hex string, prefixed by "0x". Lexical_cast does
2902 // not work.
2903 std::istringstream iss(vec[0]);
2904 iss >> std::hex >> coherentMode;
2905 ret = true;
2906 }
2907 }
2908 this->debug("[RadioHandler::executeCoherentModeQuery] Returning %s\n",
2909 this->debugBool(ret));
2910 return ret;
2911 }
2912
2913 bool RadioHandler::executeCoherentModeCommand(int& coherentMode)
2914 {
2915 this->debug("[RadioHandler::executeCoherentModeCommand] Called\n");
2916 bool ret = false;
2917 if ( this->isConnected() )
2918 {
2919 std::ostringstream oss;
2920 oss << "COH " << coherentMode << "\n";
2921 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
2922 if ( this->getLastCommandErrorInfo() == "" )
2923 {
2924 ret = true;
2925 }
2926 }
2927 this->debug("[RadioHandler::executeCoherentModeCommand] Returning %s\n",
2928 this->debugBool(ret));
2929 return ret;
2930 }
2931
2932 bool RadioHandler::executeFreqNormalizationQuery(int& fnrMode)
2933 {
2934 this->debug("[RadioHandler::executeFreqNormalizationQuery] Called\n");
2935 bool ret = false;
2936 if ( this->isConnected() )
2937 {
2938 std::ostringstream oss;
2939 oss << "FNR?" << "\n";
2940 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
2941 if ( this->getLastCommandErrorInfo() == "" )
2942 {
2943 BasicStringList vec = Pythonesque::Split(
2944 Pythonesque::Replace(rsp.front(), "FNR ", ""),
2945 ", ");
2946 // vec[0] = FNR mode indicator
2947 fnrMode = boost::lexical_cast<int>(vec[0]);
2948 ret = true;
2949 }
2950 }
2951 this->debug("[RadioHandler::executeFreqNormalizationQuery] Returning %s\n",
2952 this->debugBool(ret));
2953 return ret;
2954 }
2955
2956 bool RadioHandler::executeFreqNormalizationCommand(int& fnrMode)
2957 {
2958 this->debug("[RadioHandler::executeFreqNormalizationCommand] Called\n");
2959 bool ret = false;
2960 if ( this->isConnected() )
2961 {
2962 std::ostringstream oss;
2963 oss << "FNR " << fnrMode << "\n";
2964 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
2965 if ( this->getLastCommandErrorInfo() == "" )
2966 {
2967 ret = true;
2968 }
2969 }
2970 this->debug("[RadioHandler::executeFreqNormalizationCommand] Returning %s\n",
2971 this->debugBool(ret));
2972 return ret;
2973 }
2974
2975 bool RadioHandler::executeGpsEnabledQuery(int& enabled)
2976 {
2977 this->debug("[RadioHandler::executeGpsEnabledQuery] Called\n");
2978 bool ret = false;
2979 if ( this->isConnected() )
2980 {
2981 std::ostringstream oss;
2982 oss << "GPS?" << "\n";
2983 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
2984 if ( this->getLastCommandErrorInfo() == "" )
2985 {
2986 BasicStringList vec = Pythonesque::Split(
2987 Pythonesque::Replace(rsp.front(), "GPS ", ""),
2988 ", ");
2989 // vec[0] = GPS mode indicator
2990 enabled = boost::lexical_cast<int>(vec[0]);
2991 ret = true;
2992 }
2993 }
2994 this->debug("[RadioHandler::executeGpsEnabledQuery] Returning %s\n",
2995 this->debugBool(ret));
2996 return ret;
2997 }
2998
2999 bool RadioHandler::executeGpsPositionQuery(double& lat, double& lon)
3000 {
3001 this->debug("[RadioHandler::executeGpsPositionQuery] Called\n");
3002 bool ret = false;
3003 if ( this->isConnected() )
3004 {
3005 std::ostringstream oss;
3006 oss << "GPOS?" << "\n";
3007 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3008 if ( this->getLastCommandErrorInfo() == "" )
3009 {
3010 BasicStringList vec = Pythonesque::Split(
3011 Pythonesque::Replace(rsp.front(), "GPOS ", ""),
3012 ", ");
3013 // vec[0] = GPS position string (comma-separated NMEA)
3014 BasicStringList coords = Pythonesque::Split(vec[0], ",");
3015 lat = this->getDecimalDegreesFromNmea(coords[0]);
3016 lon = this->getDecimalDegreesFromNmea(coords[1]);
3017 ret = true;
3018 }
3019 }
3020 this->debug("[RadioHandler::executeGpsPositionQuery] Returning %s\n",
3021 this->debugBool(ret));
3022 return ret;
3023 }
3024
3025 bool RadioHandler::executeGpsEnabledCommand(int& enabled)
3026 {
3027 this->debug("[RadioHandler::executeGpsEnabledCommand] Called\n");
3028 bool ret = false;
3029 if ( this->isConnected() )
3030 {
3031 std::ostringstream oss;
3032 oss << "GPS " << enabled << "\n";
3033 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3034 if ( this->getLastCommandErrorInfo() == "" )
3035 {
3036 ret = true;
3037 }
3038 }
3039 this->debug("[RadioHandler::executeGpsEnabledCommand] Returning %s\n",
3040 this->debugBool(ret));
3041 return ret;
3042 }
3043
3044 bool RadioHandler::executeReferenceModeQuery(int& refMode)
3045 {
3046 this->debug("[RadioHandler::executeReferenceModeQuery] Called\n");
3047 bool ret = false;
3048 if ( this->isConnected() )
3049 {
3050 std::ostringstream oss;
3051 oss << "REF?" << "\n";
3052 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3053 if ( this->getLastCommandErrorInfo() == "" )
3054 {
3055 BasicStringList vec = Pythonesque::Split(
3056 Pythonesque::Replace(rsp.front(), "REF ", ""),
3057 ", ");
3058 // vec[0] = Ref mode indicator
3059 refMode = boost::lexical_cast<int>(vec[0]);
3060 ret = true;
3061 }
3062 }
3063 this->debug("[RadioHandler::executeReferenceModeQuery] Returning %s\n",
3064 this->debugBool(ret));
3065 return ret;
3066 }
3067
3068 bool RadioHandler::executeReferenceModeCommand(int& refMode)
3069 {
3070 this->debug("[RadioHandler::executeReferenceModeCommand] Called\n");
3071 bool ret = false;
3072 if ( this->isConnected() )
3073 {
3074 std::ostringstream oss;
3075 oss << "REF " << refMode << "\n";
3076 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3077 if ( this->getLastCommandErrorInfo() == "" )
3078 {
3079 ret = true;
3080 }
3081 }
3082 this->debug("[RadioHandler::executeReferenceModeCommand] Returning %s\n",
3083 this->debugBool(ret));
3084 return ret;
3085 }
3086
3087 bool RadioHandler::executeReferenceBypassQuery(int& bypassMode)
3088 {
3089 this->debug("[RadioHandler::executeReferenceBypassQuery] Called\n");
3090 bool ret = false;
3091 if ( this->isConnected() )
3092 {
3093 std::ostringstream oss;
3094 oss << "RBYP?" << "\n";
3095 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3096 if ( this->getLastCommandErrorInfo() == "" )
3097 {
3098 BasicStringList vec = Pythonesque::Split(
3099 Pythonesque::Replace(rsp.front(), "RBYP ", ""),
3100 ", ");
3101 // vec[0] = Ref bypass mode indicator
3102 bypassMode = boost::lexical_cast<int>(vec[0]);
3103 ret = true;
3104 }
3105 }
3106 this->debug("[RadioHandler::executeReferenceBypassQuery] Returning %s\n",
3107 this->debugBool(ret));
3108 return ret;
3109 }
3110
3111 bool RadioHandler::executeReferenceBypassCommand(int& bypassMode)
3112 {
3113 this->debug("[RadioHandler::executeReferenceBypassCommand] Called\n");
3114 bool ret = false;
3115 if ( this->isConnected() )
3116 {
3117 std::ostringstream oss;
3118 oss << "RBYP " << bypassMode << "\n";
3119 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3120 if ( this->getLastCommandErrorInfo() == "" )
3121 {
3122 ret = true;
3123 }
3124 }
3125 this->debug("[RadioHandler::executeReferenceBypassCommand] Returning %s\n",
3126 this->debugBool(ret));
3127 return ret;
3128 }
3129
3130 bool RadioHandler::executeReferenceVoltageQuery(int& voltage)
3131 {
3132 this->debug("[RadioHandler::executeReferenceVoltageQuery] Called\n");
3133 bool ret = false;
3134 if ( this->isConnected() )
3135 {
3136 std::ostringstream oss;
3137 oss << "RTV?" << "\n";
3138 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3139 if ( this->getLastCommandErrorInfo() == "" )
3140 {
3141 BasicStringList vec = Pythonesque::Split(
3142 Pythonesque::Replace(rsp.front(), "RTV ", ""),
3143 ", ");
3144 // vec[0] = Ref tuning voltage indicator
3145 voltage = boost::lexical_cast<int>(vec[0]);
3146 ret = true;
3147 }
3148 }
3149 this->debug("[RadioHandler::executeReferenceVoltageQuery] Returning %s\n",
3150 this->debugBool(ret));
3151 return ret;
3152 }
3153
3154 bool RadioHandler::executeReferenceVoltageCommand(int& voltage)
3155 {
3156 this->debug("[RadioHandler::executeReferenceVoltageCommand] Called\n");
3157 bool ret = false;
3158 if ( this->isConnected() )
3159 {
3160 std::ostringstream oss;
3161 oss << "RTV " << voltage << "\n";
3162 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3163 if ( this->getLastCommandErrorInfo() == "" )
3164 {
3165 ret = true;
3166 }
3167 }
3168 this->debug("[RadioHandler::executeReferenceVoltageCommand] Returning %s\n",
3169 this->debugBool(ret));
3170 return ret;
3171 }
3172
3173 bool RadioHandler::executeStatusQuery(unsigned int& stat)
3174 {
3175 this->debug("[RadioHandler::executeStatusQuery] Called\n");
3176 bool ret = false;
3177 if ( this->isConnected() )
3178 {
3179 std::ostringstream oss;
3180 oss << "STAT?" << "\n";
3181 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3182 if ( this->getLastCommandErrorInfo() == "" )
3183 {
3184 BasicStringList vec = Pythonesque::Split(
3185 Pythonesque::Replace(rsp.front(), "STAT ", ""),
3186 ", ");
3187 // vec[0] = Status
3188 // NOTE: This is a hex string, so lexical_cast will not work
3189 std::istringstream iss(vec[0]);
3190 iss >> std::hex >> stat;
3191 ret = true;
3192 }
3193 }
3194 this->debug("[RadioHandler::executeStatusQuery] Returning %s\n",
3195 this->debugBool(ret));
3196 return ret;
3197 }
3198
3199 bool RadioHandler::executeTstatusQuery(unsigned int& stat)
3200 {
3201 this->debug("[RadioHandler::executeTstatusQuery] Called\n");
3202 bool ret = false;
3203 if ( this->isConnected() )
3204 {
3205 std::ostringstream oss;
3206 oss << "TSTAT?" << "\n";
3207 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3208 if ( this->getLastCommandErrorInfo() == "" )
3209 {
3210 BasicStringList vec = Pythonesque::Split(
3211 Pythonesque::Replace(rsp.front(), "TSTAT ", ""),
3212 ", ");
3213 // vec[0] = Status
3214 // NOTE: This is a hex string, so lexical_cast will not work
3215 std::istringstream iss(vec[0]);
3216 iss >> std::hex >> stat;
3217 ret = true;
3218 }
3219 }
3220 this->debug("[RadioHandler::executeTstatusQuery] Returning %s\n",
3221 this->debugBool(ret));
3222 return ret;
3223 }
3224
3225 bool RadioHandler::executeTemperatureQuery(int& temp)
3226 {
3227 this->debug("[RadioHandler::executeTemperatureQuery] Called\n");
3228 bool ret = false;
3229 if ( this->isConnected() )
3230 {
3231 std::ostringstream oss;
3232 oss << "TEMP?" << "\n";
3233 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3234 if ( this->getLastCommandErrorInfo() == "" )
3235 {
3236 BasicStringList vec = Pythonesque::Split(
3237 Pythonesque::Replace(rsp.front(), "TEMP ", ""),
3238 ", ");
3239 // vec[0] = Temperature
3240 temp = boost::lexical_cast<int>(vec[0]);
3241 ret = true;
3242 }
3243 }
3244 this->debug("[RadioHandler::executeTemperatureQuery] Returning %s\n",
3245 this->debugBool(ret));
3246 return ret;
3247 }
3248
3249 bool RadioHandler::executeGpioStaticQuery(int& value)
3250 {
3251 this->debug("[RadioHandler::executeGpioStaticQuery] Called\n");
3252 bool ret = false;
3253 if ( this->isConnected() )
3254 {
3255 std::ostringstream oss;
3256 oss << "GPIO?" << "\n";
3257 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3258 if ( this->getLastCommandErrorInfo() == "" )
3259 {
3260 BasicStringList vec = Pythonesque::Split(
3261 Pythonesque::Replace(rsp.front(), "GPIO ", ""),
3262 ", ");
3263 // vec[0] = GPIO value
3264 // NOTE: This is a hex string, so lexical_cast will not work
3265 std::istringstream iss(vec[0]);
3266 iss >> std::hex >> value;
3267 ret = true;
3268 }
3269 }
3270 this->debug("[RadioHandler::executeGpioStaticQuery] Returning %s\n",
3271 this->debugBool(ret));
3272 return ret;
3273 }
3274
3275 bool RadioHandler::executeGpioSequenceQuery(int index, int& value,
3276 int &duration, int& loop)
3277 {
3278 this->debug("[RadioHandler::executeGpioSequenceQuery] Called\n");
3279 bool ret = false;
3280 if ( this->isConnected() )
3281 {
3282 std::ostringstream oss;
3283 oss << "GPIO? " << index << "\n";
3284 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3285 if ( this->getLastCommandErrorInfo() == "" )
3286 {
3287 BasicStringList vec = Pythonesque::Split(
3288 Pythonesque::Replace(rsp.front(), "GPIO ", ""),
3289 ", ");
3290 // vec[0] = Index
3291 // vec[1] = Value
3292 // NOTE: This is a hex string, so lexical_cast will not work
3293 std::istringstream iss(vec[1]);
3294 iss >> std::hex >> value;
3295 // vec[2] = Duration
3296 duration = boost::lexical_cast<int>(vec[2]);
3297 // vec[3] = Loop
3298 loop = boost::lexical_cast<int>(vec[3]);
3299 ret = true;
3300 }
3301 }
3302 this->debug("[RadioHandler::executeGpioSequenceQuery] Returning %s\n",
3303 this->debugBool(ret));
3304 return ret;
3305 }
3306
3307 bool RadioHandler::executeGpioStaticCommand(int& value)
3308 {
3309 this->debug("[RadioHandler::executeGpioStaticCommand] Called\n");
3310 bool ret = false;
3311 if ( this->isConnected() )
3312 {
3313 std::ostringstream oss;
3314 oss << "GPIO " << value << "\n";
3315 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3316 if ( this->getLastCommandErrorInfo() == "" )
3317 {
3318 ret = true;
3319 }
3320 }
3321 this->debug("[RadioHandler::executeGpioStaticCommand] Returning %s\n",
3322 this->debugBool(ret));
3323 return ret;
3324 }
3325
3326 bool RadioHandler::executeGpioSequenceCommand(int index, int& value,
3327 int &duration, int& loop,
3328 int &go)
3329 {
3330 this->debug("[RadioHandler::executeGpioSequenceCommand] Called\n");
3331 bool ret = false;
3332 if ( this->isConnected() )
3333 {
3334 std::ostringstream oss;
3335 oss << "GPIO " << index
3336 << ", " << value
3337 << ", " << duration
3338 << ", " << loop
3339 << ", " << go
3340 << "\n";
3341 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3342 if ( this->getLastCommandErrorInfo() == "" )
3343 {
3344 ret = true;
3345 }
3346 }
3347 this->debug("[RadioHandler::executeGpioSequenceCommand] Returning %s\n",
3348 this->debugBool(ret));
3349 return ret;
3350 }
3351
3352 bool RadioHandler::executeCalibFrequencyQuery(double& freq)
3353 {
3354 this->debug("[RadioHandler::executeCalibFrequencyQuery] Called\n");
3355 bool ret = false;
3356 if ( this->isConnected() )
3357 {
3358 std::ostringstream oss;
3359 oss << "CALF?" << "\n";
3360 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3361 if ( this->getLastCommandErrorInfo() == "" )
3362 {
3363 BasicStringList vec = Pythonesque::Split(
3364 Pythonesque::Replace(rsp.front(), "CALF ", ""),
3365 ", ");
3366 // vec[0] = Calibration freq
3367 freq = boost::lexical_cast<double>(vec[0]);
3368 ret = true;
3369 }
3370 }
3371 this->debug("[RadioHandler::executeCalibFrequencyQuery] Returning %s\n",
3372 this->debugBool(ret));
3373 return ret;
3374 }
3375
3376 bool RadioHandler::executeCalibFrequencyCommand(double& freq)
3377 {
3378 this->debug("[RadioHandler::executeCalibFrequencyCommand] Called\n");
3379 bool ret = false;
3380 if ( this->isConnected() )
3381 {
3382 std::ostringstream oss;
3383 oss << "CALF " << freq
3384 << "\n";
3385 BasicStringList rsp = this->sendCommand(oss.str(), 2.0);
3386 if ( this->getLastCommandErrorInfo() == "" )
3387 {
3388 ret = true;
3389 }
3390 }
3391 this->debug("[RadioHandler::executeCalibFrequencyCommand] Returning %s\n",
3392 this->debugBool(ret));
3393 return ret;
3394 }
3395
3396 double RadioHandler::getDecimalDegreesFromNmea(const std::string& coord)
3397 {
3398 double ret = 0.0;
3399 // Get the sign from the directional indicator
3400 int sgn = 1;
3401 if ( (coord[0] == 'W') || (coord[0] == 'S') )
3402 sgn = -1;
3403 // Find the decimal point position
3404 std::string::size_type dotPos = coord.find('.');
3405 // Get the degrees part of the string, then convert to decimal
3406 std::string degPart = coord.substr(1, dotPos - 3);
3407 double degs = boost::lexical_cast<double>(degPart);
3408 // Get the minutes part of the string, then convert to decimal
3409 std::string minPart = coord.substr(dotPos - 2, std::string::npos);
3410 double mins = boost::lexical_cast<double>(minPart);
3411 // Calculate decimal degrees
3412 ret = degs + mins / 60.0;
3413 ret = ret * sgn;
3414 return ret;
3415 }
3416
3417 uint32_t RadioHandler::getMessageId( void )
3418 {
3419 return 0;
3420 }
3421
3422 } /* namespace Driver */
3423
3424} /* namespace LibCyberRadio */
3425
LibCyberRadio::Debuggable::debugBool
virtual const char * debugBool(bool x)
Gets a debug output string for a Boolean value.
Definition Debuggable.cpp:126
LibCyberRadio::Debuggable::debug
virtual int debug(const char *format,...)
Outputs debug information.
Definition Debuggable.cpp:95
LibCyberRadio::Driver::Configurable::setConfiguration
virtual bool setConfiguration(ConfigurationDict &cfg)
Sets the configuration dictionary for this object.
Definition Configurable.cpp:161
LibCyberRadio::Driver::Configurable::getConfigurationValueAsInt
virtual int getConfigurationValueAsInt(const std::string &key) const
Gets a named configuration value as an integer value.
Definition Configurable.cpp:122
LibCyberRadio::Driver::Configurable::getConfigurationValueAsDbl
virtual double getConfigurationValueAsDbl(const std::string &key) const
Gets a named configuration value as a double value.
Definition Configurable.cpp:148
LibCyberRadio::Driver::Configurable::operator=
virtual Configurable & operator=(const Configurable &other)
Assignment operator for Configurable objects.
Definition Configurable.cpp:73
LibCyberRadio::Driver::Configurable::Configurable
Configurable(const std::string &name="<unknown>", bool debug=false)
Constructs a Configurable object.
Definition Configurable.cpp:57
LibCyberRadio::Driver::ConfigurationDict
A configuration dictionary.
Definition Configurable.h:52
LibCyberRadio::Driver::RadioHandler::setWbddcDataPort
virtual bool setWbddcDataPort(int index, int port)
Sets the data port for a given WBDDC.
Definition RadioHandler.cpp:1134
LibCyberRadio::Driver::RadioHandler::getDucTxChannelBitmap
virtual int getDucTxChannelBitmap(int index) const
Gets the transmit channel bitmap for a given DUC.
Definition RadioHandler.cpp:2025
LibCyberRadio::Driver::RadioHandler::getDataPortDestSourcePort
virtual unsigned int getDataPortDestSourcePort(int index, int dipIndex) const
Gets the source UDP port number for a given entry in the destination IP table on a given data port.
Definition RadioHandler.cpp:2425
LibCyberRadio::Driver::RadioHandler::isNbddcEnabled
virtual bool isNbddcEnabled(int index) const
Gets whether or not a given NBDDC is enabled.
Definition RadioHandler.cpp:1228
LibCyberRadio::Driver::RadioHandler::setConfiguration
virtual bool setConfiguration(ConfigurationDict &cfg)
Sets the configuration dictionary for this object.
Definition RadioHandler.cpp:394
LibCyberRadio::Driver::RadioHandler::isTunerEnabled
virtual bool isTunerEnabled(int index) const
Gets whether or not a given tuner is enabled.
Definition RadioHandler.cpp:823
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepStartFrequency
virtual double getTransmitterCWSweepStartFrequency(int index, int cwIndex) const
Gets the start frequency for a signal sweep for a given CW tone generator.
Definition RadioHandler.cpp:1799
LibCyberRadio::Driver::RadioHandler::getDucRateSet
virtual DucRateSet getDucRateSet() const
Gets the DUC's rate set.
Definition RadioHandler.cpp:2092
LibCyberRadio::Driver::RadioHandler::transmitterSupportsCWSweep
virtual bool transmitterSupportsCWSweep() const
Gets whether the transmitter supports CW tone sweeping.
Definition RadioHandler.cpp:1621
LibCyberRadio::Driver::RadioHandler::getWbddcFrequencyRes
virtual double getWbddcFrequencyRes() const
Gets the tuned frequency resolution for WBDDCs.
Definition RadioHandler.cpp:958
LibCyberRadio::Driver::RadioHandler::setSimpleSourceIPAddress
virtual bool setSimpleSourceIPAddress(const std::string &ipAddr)
Sets the source IP address for radios without 10Gig data ports.
Definition RadioHandler.cpp:2510
LibCyberRadio::Driver::RadioHandler::setDataPortConfiguration
virtual bool setDataPortConfiguration(int index, ConfigurationDict &cfg)
Sets the configuration dictionary for a given data port.
Definition RadioHandler.cpp:2332
LibCyberRadio::Driver::RadioHandler::isWbddcTunable
virtual bool isWbddcTunable() const
Gets whether the WBDDCs on this radio are tunable.
Definition RadioHandler.cpp:931
LibCyberRadio::Driver::RadioHandler::setSimpleDestMACAddress
virtual bool setSimpleDestMACAddress(const std::string &macAddr)
Sets the destination MAC address for radios without 10Gig data ports.
Definition RadioHandler.cpp:2522
LibCyberRadio::Driver::RadioHandler::setDucStreamId
virtual bool setDucStreamId(int index, unsigned int sid)
Sets the VITA 49 stream ID for a given DUC.
Definition RadioHandler.cpp:2070
LibCyberRadio::Driver::RadioHandler::setDucFrequency
virtual bool setDucFrequency(int index, double freq)
Sets the tuned frequency for a given DUC.
Definition RadioHandler.cpp:1935
LibCyberRadio::Driver::RadioHandler::RadioHandler
RadioHandler(const std::string &name="NDR", int numTuner=0, int tunerIndexBase=1, int numWbddc=0, int wbddcIndexBase=1, int numNbddc=0, int nbddcIndexBase=1, int numTunerBoards=1, int maxTunerBw=0, int numTransmitter=0, int transmitterIndexBase=1, int numDuc=0, int ducIndexBase=1, int numWbddcGroups=0, int wbddcGroupIndexBase=1, int numNbddcGroups=0, int nbddcGroupIndexBase=1, int numDdcGroups=0, int ddcGroupIndexBase=1, int numDataPorts=0, int dataPortIndexBase=1, int numSimpleIpSetups=0, double adcRate=102.4e6, VitaIfSpec ifSpec=VitaIfSpec(), bool debug=false)
Constructs a RadioHandler object.
Definition RadioHandler.cpp:28
LibCyberRadio::Driver::RadioHandler::getDataPortDipEntryIndexRange
virtual BasicIntList getDataPortDipEntryIndexRange() const
Gets the list of UDP destination table indices for the 10GigE data ports on the radio.
Definition RadioHandler.cpp:696
LibCyberRadio::Driver::RadioHandler::getTransmitterIndexRange
virtual BasicIntList getTransmitterIndexRange() const
Gets the list of transmitter indices on the radio.
Definition RadioHandler.cpp:1409
LibCyberRadio::Driver::RadioHandler::setWbddcUdpDestination
virtual bool setWbddcUdpDestination(int index, int dest)
Sets the UDP destination for a given WBDDC.
Definition RadioHandler.cpp:1080
LibCyberRadio::Driver::RadioHandler::getTransmitterFrequencyRange
virtual BasicDoubleList getTransmitterFrequencyRange() const
Gets the frequency range for the transmitters on the radio.
Definition RadioHandler.cpp:1418
LibCyberRadio::Driver::RadioHandler::getConnectionModeList
virtual BasicStringList getConnectionModeList() const
Gets the list of connection methods that the radio supports.
Definition RadioHandler.cpp:705
LibCyberRadio::Driver::RadioHandler::enableWbddcGroup
virtual bool enableWbddcGroup(int index, bool enabled)
Enables a given WBDDC group.
Definition RadioHandler.cpp:2132
LibCyberRadio::Driver::RadioHandler::getTemperature
virtual int getTemperature()
Gets the current radio temperature.
Definition RadioHandler.cpp:598
LibCyberRadio::Driver::RadioHandler::setDataPortDestSourcePort
virtual bool setDataPortDestSourcePort(int index, int dipIndex, unsigned int sourcePort)
Sets the UDP port number for a given entry in the destination IP table on a given data port.
Definition RadioHandler.cpp:2434
LibCyberRadio::Driver::RadioHandler::getNumNbddcGroups
virtual int getNumNbddcGroups() const
Gets the number of NBDDC groups on the radio.
Definition RadioHandler.cpp:2200
LibCyberRadio::Driver::RadioHandler::setWbddcRateIndex
virtual bool setWbddcRateIndex(int index, int rateIndex)
Sets the rate index for a given WBDDC.
Definition RadioHandler.cpp:1062
LibCyberRadio::Driver::RadioHandler::getWbddcRateSet
virtual WbddcRateSet getWbddcRateSet() const
Gets the WBDDC rate set.
Definition RadioHandler.cpp:976
LibCyberRadio::Driver::RadioHandler::getStatus
virtual unsigned int getStatus()
Gets the status from the radio.
Definition RadioHandler.cpp:540
LibCyberRadio::Driver::RadioHandler::getTunerAttenuationRes
virtual double getTunerAttenuationRes() const
Gets the attenuation resolution.
Definition RadioHandler.cpp:814
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepStepRes
virtual double getTransmitterCWSweepStepRes() const
Gets the CW frequency step resolution.
Definition RadioHandler.cpp:1675
LibCyberRadio::Driver::RadioHandler::getWbddcSource
virtual int getWbddcSource(int index) const
Gets the source (which tuner is supplying the signal) for a given WBDDC.
Definition RadioHandler.cpp:1035
LibCyberRadio::Driver::RadioHandler::setTransmitterAttenuation
virtual bool setTransmitterAttenuation(int index, double atten)
Sets the attenuation for a given transmitter.
Definition RadioHandler.cpp:1513
LibCyberRadio::Driver::RadioHandler::getNbddcRateSet
virtual NbddcRateSet getNbddcRateSet() const
Gets the NBDDC rate set.
Definition RadioHandler.cpp:1210
LibCyberRadio::Driver::RadioHandler::setTransmitterConfiguration
virtual bool setTransmitterConfiguration(int index, ConfigurationDict &cfg)
Sets the configuration dictionary for a given transmitter.
Definition RadioHandler.cpp:1531
LibCyberRadio::Driver::RadioHandler::setDucTxChannelBitmap
virtual bool setDucTxChannelBitmap(int index, int txChannels)
Sets the transmit channel bitmap for a given DUC.
Definition RadioHandler.cpp:2034
LibCyberRadio::Driver::RadioHandler::getMessageId
virtual uint32_t getMessageId(void)
Get a json Message ID.
Definition RadioHandler.cpp:3417
LibCyberRadio::Driver::RadioHandler::getNumDuc
virtual int getNumDuc() const
Gets the number of DUCs on the radio.
Definition RadioHandler.cpp:1845
LibCyberRadio::Driver::RadioHandler::getTransmitterCWFrequency
virtual double getTransmitterCWFrequency(int index, int cwIndex) const
Gets the constant frequency for a given CW tone generator.
Definition RadioHandler.cpp:1736
LibCyberRadio::Driver::RadioHandler::setTransmitterFrequency
virtual bool setTransmitterFrequency(int index, double freq)
Sets the frequency for a given transmitter.
Definition RadioHandler.cpp:1495
LibCyberRadio::Driver::RadioHandler::isWbddcSelectableSource
virtual bool isWbddcSelectableSource() const
Gets whether the WBDDCs on this radio support selecting their tuner source.
Definition RadioHandler.cpp:940
LibCyberRadio::Driver::RadioHandler::getWbddcGroupIndexRange
virtual BasicIntList getWbddcGroupIndexRange() const
Gets the range of WBDDC group indices on the radio.
Definition RadioHandler.cpp:2115
LibCyberRadio::Driver::RadioHandler::getDucMode
virtual int getDucMode(int index) const
Gets the mode for a given DUC.
Definition RadioHandler.cpp:2043
LibCyberRadio::Driver::RadioHandler::enableNbddcGroup
virtual bool enableNbddcGroup(int index, bool enabled)
Enables a given NBDDC group.
Definition RadioHandler.cpp:2222
LibCyberRadio::Driver::RadioHandler::setDucRateIndex
virtual bool setDucRateIndex(int index, int rateIndex)
Sets the rate index for a given DUC.
Definition RadioHandler.cpp:2016
LibCyberRadio::Driver::RadioHandler::setNbddcRateIndex
virtual bool setNbddcRateIndex(int index, int rateIndex)
Sets the rate index for a given NBDDC.
Definition RadioHandler.cpp:1314
LibCyberRadio::Driver::RadioHandler::getWbddcIndexRange
virtual BasicIntList getWbddcIndexRange() const
Gets the range of WBDDC indices on the radio.
Definition RadioHandler.cpp:923
LibCyberRadio::Driver::RadioHandler::getDucAttenuationRes
virtual double getDucAttenuationRes() const
Gets the DUC attenuation resolution.
Definition RadioHandler.cpp:1998
LibCyberRadio::Driver::RadioHandler::isConnectionModeSupported
virtual bool isConnectionModeSupported(const std::string &mode) const
Gets whether the radio supports the given connection mode.
Definition RadioHandler.cpp:710
LibCyberRadio::Driver::RadioHandler::isNbddcGroupEnabled
virtual bool isNbddcGroupEnabled(int index) const
Gets whether or not a given NBDDC group is enabled.
Definition RadioHandler.cpp:2213
LibCyberRadio::Driver::RadioHandler::connect
virtual bool connect(const std::string &mode, const std::string &host_or_dev, const int port_or_baudrate)
Connects to the radio.
Definition RadioHandler.cpp:260
LibCyberRadio::Driver::RadioHandler::setDataPortDestDestPort
virtual bool setDataPortDestDestPort(int index, int dipIndex, unsigned int destPort)
Sets the VITA stream ID for a given entry in the destination IP table on a given data port.
Definition RadioHandler.cpp:2453
LibCyberRadio::Driver::RadioHandler::getTransmitterCWPhase
virtual double getTransmitterCWPhase(int index, int cwIndex) const
Gets the signal phase for a given CW tone generator.
Definition RadioHandler.cpp:1772
LibCyberRadio::Driver::RadioHandler::getDucFrequencyRange
virtual BasicDoubleList getDucFrequencyRange() const
Gets the tunable frequency range for DUCs.
Definition RadioHandler.cpp:1944
LibCyberRadio::Driver::RadioHandler::disableTenGigFlowControl
virtual bool disableTenGigFlowControl()
Disables flow control on all 10GigE data ports.
Definition RadioHandler.cpp:2290
LibCyberRadio::Driver::RadioHandler::getTransmitterCWAmplitude
virtual double getTransmitterCWAmplitude(int index, int cwIndex) const
Gets the signal amplitude for a given CW tone generator.
Definition RadioHandler.cpp:1754
LibCyberRadio::Driver::RadioHandler::getDucFrequencyRes
virtual double getDucFrequencyRes() const
Gets the tuned frequency resolution for DUCs.
Definition RadioHandler.cpp:1953
LibCyberRadio::Driver::RadioHandler::getNbddcStreamId
virtual unsigned int getNbddcStreamId(int index) const
Gets the VITA 49 stream ID for a given NBDDC.
Definition RadioHandler.cpp:1359
LibCyberRadio::Driver::RadioHandler::ducSupportsSnapshotTransmit
virtual bool ducSupportsSnapshotTransmit() const
Gets whether DUCs support transmitting snapshots.
Definition RadioHandler.cpp:1867
LibCyberRadio::Driver::RadioHandler::setTunerConfiguration
virtual bool setTunerConfiguration(int index, ConfigurationDict &cfg)
Sets the configuration dictionary for a given tuner.
Definition RadioHandler.cpp:909
LibCyberRadio::Driver::RadioHandler::getConnectionInfo
virtual BasicStringStringDict getConnectionInfo()
Gets connection information for the radio.
Definition RadioHandler.cpp:255
LibCyberRadio::Driver::RadioHandler::setNbddcConfiguration
virtual bool setNbddcConfiguration(int index, ConfigurationDict &cfg)
Sets the configuration dictionary for a given NBDDC.
Definition RadioHandler.cpp:1260
LibCyberRadio::Driver::RadioHandler::addNbddcGroupMember
virtual bool addNbddcGroupMember(int index, int member)
Adds a NBDDC to the given NBDDC group.
Definition RadioHandler.cpp:2272
LibCyberRadio::Driver::RadioHandler::setWbddcFrequency
virtual bool setWbddcFrequency(int index, double freq)
Sets the tuned frequency for a given WBDDC.
Definition RadioHandler.cpp:1026
LibCyberRadio::Driver::RadioHandler::isByteswapped
virtual bool isByteswapped() const
Gets whether the VITA 49 is byte-swapped with respect to the host operating system.
Definition RadioHandler.cpp:740
LibCyberRadio::Driver::RadioHandler::setTransmitterCWAmplitude
virtual bool setTransmitterCWAmplitude(int index, int cwIndex, double amp)
Sets the signal amplitude for a given CW tone generator.
Definition RadioHandler.cpp:1763
LibCyberRadio::Driver::RadioHandler::getNbddcUdpDestination
virtual int getNbddcUdpDestination(int index) const
Gets the UDP destination for a given NBDDC.
Definition RadioHandler.cpp:1323
LibCyberRadio::Driver::RadioHandler::enableWbddc
virtual bool enableWbddc(int index, bool enabled=true)
Enables a given WBDDC.
Definition RadioHandler.cpp:1003
LibCyberRadio::Driver::RadioHandler::isTransmitterEnabled
virtual bool isTransmitterEnabled(int index) const
Gets whether a given transmitter is enabled.
Definition RadioHandler.cpp:1463
LibCyberRadio::Driver::RadioHandler::getGpsPosition
virtual BasicDoubleList getGpsPosition()
Gets the current GPS position the radio.
Definition RadioHandler.cpp:585
LibCyberRadio::Driver::RadioHandler::getDataPortDestIPAddress
virtual std::string getDataPortDestIPAddress(int index, int dipIndex) const
Gets the IP address for a given entry in the destination IP table on a given data port.
Definition RadioHandler.cpp:2406
LibCyberRadio::Driver::RadioHandler::setSimpleIPConfiguration
virtual bool setSimpleIPConfiguration(ConfigurationDict &cfg)
Sets the "simple" IP configuration dictionary for radios without 10Gig data ports.
Definition RadioHandler.cpp:2488
LibCyberRadio::Driver::RadioHandler::getTimeNow
virtual time_t getTimeNow()
Gets the current radio time.
Definition RadioHandler.cpp:515
LibCyberRadio::Driver::RadioHandler::setReferenceMode
virtual bool setReferenceMode(int mode)
Sets the reference mode on the radio.
Definition RadioHandler.cpp:562
LibCyberRadio::Driver::RadioHandler::getTunerFrequencyUnit
virtual double getTunerFrequencyUnit() const
Gets the tuned frequency units for tuners.
Definition RadioHandler.cpp:796
LibCyberRadio::Driver::RadioHandler::setDataPortSourceIP
virtual bool setDataPortSourceIP(int index, const std::string &ipAddr)
Sets the source IP address for a given data port.
Definition RadioHandler.cpp:2350
LibCyberRadio::Driver::RadioHandler::getLastCommandErrorInfo
virtual std::string getLastCommandErrorInfo() const
Gets the error message from the last command attempted.
Definition RadioHandler.cpp:463
LibCyberRadio::Driver::RadioHandler::getDucRateIndex
virtual int getDucRateIndex(int index) const
Gets the rate index for a given DUC.
Definition RadioHandler.cpp:2007
LibCyberRadio::Driver::RadioHandler::getNumTransmitters
virtual int getNumTransmitters() const
Gets the number of transmitters on the radio.
Definition RadioHandler.cpp:1404
LibCyberRadio::Driver::RadioHandler::setSimpleDestIPAddress
virtual bool setSimpleDestIPAddress(const std::string &ipAddr)
Sets the destination IP address for radios without 10Gig data ports.
Definition RadioHandler.cpp:2534
LibCyberRadio::Driver::RadioHandler::setTimeAdjustment
virtual bool setTimeAdjustment(int tunerIndex, int timeAdjustValue)
Sets the time adjustment for tuners on the radio.
Definition RadioHandler.cpp:576
LibCyberRadio::Driver::RadioHandler::getWbddcUdpDestination
virtual int getWbddcUdpDestination(int index) const
Gets the UDP destination for a given WBDDC.
Definition RadioHandler.cpp:1071
LibCyberRadio::Driver::RadioHandler::setDucConfiguration
virtual bool setDucConfiguration(int index, ConfigurationDict &cfg)
Sets the configuration dictionary for a given DUC.
Definition RadioHandler.cpp:1899
LibCyberRadio::Driver::RadioHandler::setDataPortDestIPAddress
virtual bool setDataPortDestIPAddress(int index, int dipIndex, const std::string &ipAddr)
Sets the IP address for a given entry in the destination IP table on a given data port.
Definition RadioHandler.cpp:2415
LibCyberRadio::Driver::RadioHandler::getSimpleSourceIPAddress
virtual std::string getSimpleSourceIPAddress() const
Gets the source IP address for radios without 10Gig data ports.
Definition RadioHandler.cpp:2504
LibCyberRadio::Driver::RadioHandler::enableDataPortFlowControl
virtual bool enableDataPortFlowControl(int index, bool enabled=true)
Enables flow control on the data port.
Definition RadioHandler.cpp:2373
LibCyberRadio::Driver::RadioHandler::getTransmitterAttenuationRange
virtual BasicDoubleList getTransmitterAttenuationRange() const
Gets the attenuation range for the transmitters on the radio.
Definition RadioHandler.cpp:1445
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepStartRange
virtual BasicDoubleList getTransmitterCWSweepStartRange() const
Gets the CW start frequency range.
Definition RadioHandler.cpp:1630
LibCyberRadio::Driver::RadioHandler::getPps
virtual bool getPps()
Gets the pulse-per-second (PPS) rising edge from the radio.
Definition RadioHandler.cpp:473
LibCyberRadio::Driver::RadioHandler::getTunerConfiguration
virtual ConfigurationDict getTunerConfiguration(int index) const
Gets the configuration dictionary for a given tuner.
Definition RadioHandler.cpp:900
LibCyberRadio::Driver::RadioHandler::getTransmitterCWIndexRange
virtual BasicIntList getTransmitterCWIndexRange() const
Gets the range of indices for CW tone generators.
Definition RadioHandler.cpp:1558
LibCyberRadio::Driver::RadioHandler::getWbddcFrequencyRange
virtual BasicDoubleList getWbddcFrequencyRange() const
Gets the tunable frequency range for WBDDCs.
Definition RadioHandler.cpp:949
LibCyberRadio::Driver::RadioHandler::isIqSwapped
virtual bool isIqSwapped() const
Gets whether the VITA 49 format swaps real and imaginary (I and Q) portions of each sample.
Definition RadioHandler.cpp:750
LibCyberRadio::Driver::RadioHandler::getWbddcFrequency
virtual double getWbddcFrequency(int index) const
Gets the tuned frequency for a given WBDDC.
Definition RadioHandler.cpp:1017
LibCyberRadio::Driver::RadioHandler::getSimpleDestMACAddress
virtual std::string getSimpleDestMACAddress() const
Gets the destination MAC address for radios without 10Gig data ports.
Definition RadioHandler.cpp:2516
LibCyberRadio::Driver::RadioHandler::setDataPortDestInfo
virtual bool setDataPortDestInfo(int index, int dipIndex, const std::string &ipAddr, const std::string &macAddr, unsigned int sourcePort, unsigned int destPort)
Sets the destination table information for a given entry in the DIP table on a given data port.
Definition RadioHandler.cpp:2463
LibCyberRadio::Driver::RadioHandler::getDataPortDestMACAddress
virtual std::string getDataPortDestMACAddress(int index, int dipIndex) const
Gets the MAC address for a given entry in the destination IP table on a given data port.
Definition RadioHandler.cpp:2387
LibCyberRadio::Driver::RadioHandler::enableTransmitter
virtual bool enableTransmitter(int index, bool enabled=true)
Enables a given transmitter.
Definition RadioHandler.cpp:1472
LibCyberRadio::Driver::RadioHandler::getNbddcFrequency
virtual double getNbddcFrequency(int index) const
Gets the tuned frequency for a given NBDDC.
Definition RadioHandler.cpp:1269
LibCyberRadio::Driver::RadioHandler::setWbddcGroupMembers
virtual bool setWbddcGroupMembers(int index, const BasicIntList &groupMembers)
Sets the list of group members for a given WBDDC group.
Definition RadioHandler.cpp:2173
LibCyberRadio::Driver::RadioHandler::setDataPortDestMACAddress
virtual bool setDataPortDestMACAddress(int index, int dipIndex, const std::string &macAddr)
Sets the MAC address for a given entry in the destination IP table on a given data port.
Definition RadioHandler.cpp:2396
LibCyberRadio::Driver::RadioHandler::setTransmitterCWFrequency
virtual bool setTransmitterCWFrequency(int index, int cwIndex, double freq)
Sets the constant frequency for a given CW tone generator.
Definition RadioHandler.cpp:1745
LibCyberRadio::Driver::RadioHandler::getDataPortIndexRange
virtual BasicIntList getDataPortIndexRange() const
Gets the range of indices 10GigE data ports on the radio.
Definition RadioHandler.cpp:679
LibCyberRadio::Driver::RadioHandler::setGpioOutputByIndex
virtual bool setGpioOutputByIndex(int index, int value, int duration, int loop, int go)
Sets the GPIO output settings for a given sequence index.
Definition RadioHandler.cpp:649
LibCyberRadio::Driver::RadioHandler::addWbddcGroupMember
virtual bool addWbddcGroupMember(int index, int member)
Adds a WBDDC to the given WBDDC group.
Definition RadioHandler.cpp:2182
LibCyberRadio::Driver::RadioHandler::getNbddcDataPort
virtual int getNbddcDataPort(int index) const
Gets the data port for a given NBDDC.
Definition RadioHandler.cpp:1377
LibCyberRadio::Driver::RadioHandler::getTransmitterAttenuationRes
virtual double getTransmitterAttenuationRes() const
Gets the attenuation resolution for transmitters on the radio.
Definition RadioHandler.cpp:1454
LibCyberRadio::Driver::RadioHandler::ducSupportsSnapshotLoad
virtual bool ducSupportsSnapshotLoad() const
Gets whether DUCs support loading snapshot files.
Definition RadioHandler.cpp:1858
LibCyberRadio::Driver::RadioHandler::getWbddcFrequencyUnit
virtual double getWbddcFrequencyUnit() const
Gets the tuned frequency units for WBDDCs.
Definition RadioHandler.cpp:967
LibCyberRadio::Driver::RadioHandler::getVitaHeaderSize
virtual int getVitaHeaderSize() const
Gets the size of the VITA 49 header.
Definition RadioHandler.cpp:725
LibCyberRadio::Driver::RadioHandler::disableDataPortFlowControl
virtual bool disableDataPortFlowControl(int index)
Disables flow control on the data port.
Definition RadioHandler.cpp:2382
LibCyberRadio::Driver::RadioHandler::setNbddcSource
virtual bool setNbddcSource(int index, int source)
Sets the source (which tuner is supplying the signal) for a given NBDDC.
Definition RadioHandler.cpp:1296
LibCyberRadio::Driver::RadioHandler::setWbddcRateSet
virtual bool setWbddcRateSet(int index, const WbddcRateSet &set)
Sets the rate set for a given WBDDC.
Definition RadioHandler.cpp:1143
LibCyberRadio::Driver::RadioHandler::getSimpleIPConfiguration
virtual ConfigurationDict getSimpleIPConfiguration() const
Gets the "simple" IP configuration dictionary for radios without 10Gig data ports.
Definition RadioHandler.cpp:2478
LibCyberRadio::Driver::RadioHandler::setTransmitterCWFrequencySweep
virtual bool setTransmitterCWFrequencySweep(int index, int cwIndex, double start, double stop, double step, double dwell)
Sets the parameters for a frequency sweep for a given CW tone generator.
Definition RadioHandler.cpp:1835
LibCyberRadio::Driver::RadioHandler::getTransmitterCWFrequencyRange
virtual BasicDoubleList getTransmitterCWFrequencyRange() const
Gets the CW frequency range.
Definition RadioHandler.cpp:1567
LibCyberRadio::Driver::RadioHandler::disableNbddc
virtual bool disableNbddc(int index)
Disables a given NBDDC.
Definition RadioHandler.cpp:1246
LibCyberRadio::Driver::RadioHandler::disableTransmitter
virtual bool disableTransmitter(int index)
Disables a given transmitter.
Definition RadioHandler.cpp:1481
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepDwellTime
virtual double getTransmitterCWSweepDwellTime(int index, int cwIndex) const
Gets the dwell time for a signal sweep for a given CW tone generator.
Definition RadioHandler.cpp:1826
LibCyberRadio::Driver::RadioHandler::setTunerFrequency
virtual bool setTunerFrequency(int index, double freq)
Sets the tuned frequency for a given tuner.
Definition RadioHandler.cpp:855
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepDwellRes
virtual double getTransmitterCWSweepDwellRes() const
Gets the CW dwell time resolution.
Definition RadioHandler.cpp:1693
LibCyberRadio::Driver::RadioHandler::transmitterSupportsCW
virtual bool transmitterSupportsCW() const
Gets whether transmitters support continuous-wave (CW) tone generation.
Definition RadioHandler.cpp:1540
LibCyberRadio::Driver::RadioHandler::getCalibrationFrequency
virtual double getCalibrationFrequency() const
Gets the calibration frequency.
Definition RadioHandler.cpp:662
LibCyberRadio::Driver::RadioHandler::getVitaPayloadSize
virtual int getVitaPayloadSize() const
Gets the size of the VITA 49 payload.
Definition RadioHandler.cpp:730
LibCyberRadio::Driver::RadioHandler::disableTransmitterCW
virtual bool disableTransmitterCW(int index, int cwIndex)
Disables a given CW tone generator.
Definition RadioHandler.cpp:1711
LibCyberRadio::Driver::RadioHandler::getTransmitterFrequencyUnit
virtual double getTransmitterFrequencyUnit() const
Gets the frequency unit for transmitters on the radio.
Definition RadioHandler.cpp:1436
LibCyberRadio::Driver::RadioHandler::setNbddcVitaEnable
virtual bool setNbddcVitaEnable(int index, int enable)
Sets the VITA 49 setting for a given NBDDC.
Definition RadioHandler.cpp:1350
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepFrequencyStep
virtual double getTransmitterCWSweepFrequencyStep(int index, int cwIndex) const
Gets the frequency step for a signal sweep for a given CW tone generator.
Definition RadioHandler.cpp:1817
LibCyberRadio::Driver::RadioHandler::setNbddcStreamId
virtual bool setNbddcStreamId(int index, unsigned int sid)
Sets the VITA 49 stream ID for a given NBDDC.
Definition RadioHandler.cpp:1368
LibCyberRadio::Driver::RadioHandler::removeNbddcGroupMember
virtual bool removeNbddcGroupMember(int index, int member)
Removes a NBDDC from the given NBDDC group.
Definition RadioHandler.cpp:2281
LibCyberRadio::Driver::RadioHandler::getNumDataPortDipEntries
virtual int getNumDataPortDipEntries() const
Gets the number of UDP destination table entries for the 10GigE data ports on the radio.
Definition RadioHandler.cpp:687
LibCyberRadio::Driver::RadioHandler::getNumTunerBoards
virtual int getNumTunerBoards() const
Gets the number of tuner boards on the radio.
Definition RadioHandler.cpp:765
LibCyberRadio::Driver::RadioHandler::getDataPortConfiguration
virtual ConfigurationDict getDataPortConfiguration(int index) const
Gets the configuration dictionary for a given data port.
Definition RadioHandler.cpp:2323
LibCyberRadio::Driver::RadioHandler::getWbddcGroupConfiguration
virtual ConfigurationDict getWbddcGroupConfiguration(int index) const
Gets the configuration dictionary for a given WBDDC group.
Definition RadioHandler.cpp:2146
LibCyberRadio::Driver::RadioHandler::getNbddcGroupMembers
virtual BasicIntList getNbddcGroupMembers(int index) const
Gets the list of group members for a given NBDDC group.
Definition RadioHandler.cpp:2254
LibCyberRadio::Driver::RadioHandler::getDataPortSourceIP
virtual std::string getDataPortSourceIP(int index) const
Gets the source IP address for a given data port.
Definition RadioHandler.cpp:2341
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepStopFrequency
virtual double getTransmitterCWSweepStopFrequency(int index, int cwIndex) const
Gets the stop frequency for a signal sweep for a given CW tone generator.
Definition RadioHandler.cpp:1808
LibCyberRadio::Driver::RadioHandler::getNumNbddc
virtual int getNumNbddc() const
Gets the number of NBDDCs on the radio.
Definition RadioHandler.cpp:1170
LibCyberRadio::Driver::RadioHandler::getNumDataPorts
virtual int getNumDataPorts() const
Gets the number of 10GigE data ports on the radio.
Definition RadioHandler.cpp:609
LibCyberRadio::Driver::RadioHandler::isConnected
virtual bool isConnected() const
Gets whether or not the handler is connected.
Definition RadioHandler.cpp:245
LibCyberRadio::Driver::RadioHandler::getNbddcVitaEnable
virtual int getNbddcVitaEnable(int index) const
Gets the VITA 49 setting for a given NBDDC.
Definition RadioHandler.cpp:1341
LibCyberRadio::Driver::RadioHandler::setBypassMode
virtual bool setBypassMode(int mode)
Sets the reference bypass mode on the radio.
Definition RadioHandler.cpp:569
LibCyberRadio::Driver::RadioHandler::setWbddcVitaEnable
virtual bool setWbddcVitaEnable(int index, int enable)
Sets the VITA 49 setting for a given WBDDC.
Definition RadioHandler.cpp:1098
LibCyberRadio::Driver::RadioHandler::getTransmitterFrequencyRes
virtual double getTransmitterFrequencyRes() const
Gets the frequency resolution for transmitters on the radio.
Definition RadioHandler.cpp:1427
LibCyberRadio::Driver::RadioHandler::getDucIndexRange
virtual BasicIntList getDucIndexRange() const
Gets the range of DUC indices on the radio.
Definition RadioHandler.cpp:1850
LibCyberRadio::Driver::RadioHandler::getNbddcGroupIndexRange
virtual BasicIntList getNbddcGroupIndexRange() const
Gets the range of NBDDC group indices on the radio.
Definition RadioHandler.cpp:2205
LibCyberRadio::Driver::RadioHandler::getWbddcConfiguration
virtual ConfigurationDict getWbddcConfiguration(int index) const
Gets the configuration dictionary for a given WBDDC.
Definition RadioHandler.cpp:1152
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepStartRes
virtual double getTransmitterCWSweepStartRes() const
Gets the CW start frequency resolution.
Definition RadioHandler.cpp:1639
LibCyberRadio::Driver::RadioHandler::getNumWbddcGroups
virtual int getNumWbddcGroups() const
Gets the number of WBDDC groups on the radio.
Definition RadioHandler.cpp:2110
LibCyberRadio::Driver::RadioHandler::setNbddcUdpDestination
virtual bool setNbddcUdpDestination(int index, int dest)
Sets the UDP destination for a given NBDDC.
Definition RadioHandler.cpp:1332
LibCyberRadio::Driver::RadioHandler::getNumTuner
virtual int getNumTuner() const
Gets the number of tuners on the radio.
Definition RadioHandler.cpp:760
LibCyberRadio::Driver::RadioHandler::setTransmitterCWConfiguration
virtual bool setTransmitterCWConfiguration(int index, int cwIndex, ConfigurationDict &cfg)
Sets the configuration dictionary for a given CW tone generator.
Definition RadioHandler.cpp:1726
LibCyberRadio::Driver::RadioHandler::setGpioOutput
virtual bool setGpioOutput(int value)
Sets the current GPIO output bits.
Definition RadioHandler.cpp:640
LibCyberRadio::Driver::RadioHandler::setWbddcGroupConfiguration
virtual bool setWbddcGroupConfiguration(int index, ConfigurationDict &cfg)
Sets the configuration dictionary for a given WBDDC group.
Definition RadioHandler.cpp:2155
LibCyberRadio::Driver::RadioHandler::getDucAttenuation
virtual double getDucAttenuation(int index) const
Gets the attenuation for a given DUC.
Definition RadioHandler.cpp:1971
LibCyberRadio::Driver::RadioHandler::getNbddcGroupConfiguration
virtual ConfigurationDict getNbddcGroupConfiguration(int index) const
Gets the configuration dictionary for a given NBDDC group.
Definition RadioHandler.cpp:2236
LibCyberRadio::Driver::RadioHandler::operator=
virtual RadioHandler & operator=(const RadioHandler &other)
Assignment operator for RadioHandler objects.
Definition RadioHandler.cpp:197
LibCyberRadio::Driver::RadioHandler::enableTenGigFlowControl
virtual bool enableTenGigFlowControl()
Enables flow control on all 10GigE data ports.
Definition RadioHandler.cpp:2295
LibCyberRadio::Driver::RadioHandler::getTransmitterCWFrequencyRes
virtual double getTransmitterCWFrequencyRes() const
Gets the CW frequency resolution.
Definition RadioHandler.cpp:1576
LibCyberRadio::Driver::RadioHandler::queryConfiguration
virtual void queryConfiguration()
Tells the radio to query its hardware configuration in order to create its configuration dictionary (...
Definition RadioHandler.cpp:342
LibCyberRadio::Driver::RadioHandler::getSimpleDestIPAddress
virtual std::string getSimpleDestIPAddress() const
Gets the destination IP address for radios without 10Gig data ports.
Definition RadioHandler.cpp:2528
LibCyberRadio::Driver::RadioHandler::disconnect
virtual void disconnect()
Disconnects from the radio.
Definition RadioHandler.cpp:299
LibCyberRadio::Driver::RadioHandler::getDucRateList
virtual BasicDoubleList getDucRateList() const
Gets the list of allowed DUC sample rates, based on the rate set.
Definition RadioHandler.cpp:2101
LibCyberRadio::Driver::RadioHandler::disableDataPortErrors
virtual bool disableDataPortErrors(int index)
Disables errors on the data port.
Definition RadioHandler.cpp:2368
LibCyberRadio::Driver::RadioHandler::getDucFrequencyUnit
virtual double getDucFrequencyUnit() const
Gets the tuned frequency units for DUCs.
Definition RadioHandler.cpp:1962
LibCyberRadio::Driver::RadioHandler::enableTransmitterCW
virtual bool enableTransmitterCW(int index, int cwIndex, bool enabled=true)
Enables a given CW tone generator.
Definition RadioHandler.cpp:1702
LibCyberRadio::Driver::RadioHandler::getNbddcConfiguration
virtual ConfigurationDict getNbddcConfiguration(int index) const
Gets the configuration dictionary for a given NBDDC.
Definition RadioHandler.cpp:1251
LibCyberRadio::Driver::RadioHandler::getWbddcVitaEnable
virtual int getWbddcVitaEnable(int index) const
Gets the VITA 49 setting for a given WBDDC.
Definition RadioHandler.cpp:1089
LibCyberRadio::Driver::RadioHandler::getWbddcRateIndex
virtual int getWbddcRateIndex(int index) const
Gets the rate index for a given WBDDC.
Definition RadioHandler.cpp:1053
LibCyberRadio::Driver::RadioHandler::getTunerFilter
virtual int getTunerFilter(int index) const
Gets the filter setting for a given tuner.
Definition RadioHandler.cpp:882
LibCyberRadio::Driver::RadioHandler::getTunerFrequencyRes
virtual double getTunerFrequencyRes() const
Gets the tuned frequency resolution.
Definition RadioHandler.cpp:787
LibCyberRadio::Driver::RadioHandler::setTransmitterCWPhase
virtual bool setTransmitterCWPhase(int index, int cwIndex, double phase)
Sets the signal phase for a given CW tone generator.
Definition RadioHandler.cpp:1781
LibCyberRadio::Driver::RadioHandler::setWbddcConfiguration
virtual bool setWbddcConfiguration(int index, ConfigurationDict &cfg)
Sets the configuration dictionary for a given WBDDC.
Definition RadioHandler.cpp:1161
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepStopRes
virtual double getTransmitterCWSweepStopRes() const
Gets the CW stop frequency resolution.
Definition RadioHandler.cpp:1657
LibCyberRadio::Driver::RadioHandler::getDataPortDestDestPort
virtual unsigned int getDataPortDestDestPort(int index, int dipIndex) const
Gets the destination UDP port number for a given entry in the destination IP table on a given data po...
Definition RadioHandler.cpp:2444
LibCyberRadio::Driver::RadioHandler::setTimeNextPps
virtual bool setTimeNextPps(bool checkTime=false, bool useGpsTime=false)
Sets the time for the next PPS rising edge on the radio.
Definition RadioHandler.cpp:478
LibCyberRadio::Driver::RadioHandler::setDucDataPort
virtual bool setDucDataPort(int index, int port)
Sets the data port for a given DUC.
Definition RadioHandler.cpp:1917
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepStopRange
virtual BasicDoubleList getTransmitterCWSweepStopRange() const
Gets the CW stop frequency range.
Definition RadioHandler.cpp:1648
LibCyberRadio::Driver::RadioHandler::setNbddcFrequency
virtual bool setNbddcFrequency(int index, double freq)
Sets the tuned frequency for a given NBDDC.
Definition RadioHandler.cpp:1278
LibCyberRadio::Driver::RadioHandler::disableTuner
virtual bool disableTuner(int index)
Disables a given tuner.
Definition RadioHandler.cpp:841
LibCyberRadio::Driver::RadioHandler::getTunerIndexRange
virtual BasicIntList getTunerIndexRange() const
Gets the tuner index range.
Definition RadioHandler.cpp:770
LibCyberRadio::Driver::RadioHandler::getDucConfiguration
virtual ConfigurationDict getDucConfiguration(int index) const
Gets the configuration dictionary for a given DUC.
Definition RadioHandler.cpp:1890
LibCyberRadio::Driver::RadioHandler::getTunerFrequency
virtual double getTunerFrequency(int index) const
Gets the tuned frequency for a given tuner.
Definition RadioHandler.cpp:846
LibCyberRadio::Driver::RadioHandler::setDucAttenuation
virtual bool setDucAttenuation(int index, double atten)
Sets the attenuation for a given DUC.
Definition RadioHandler.cpp:1980
LibCyberRadio::Driver::RadioHandler::updateConfigurationDict
virtual void updateConfigurationDict()
Updates the configuration dictionary from object settings.
Definition RadioHandler.cpp:2561
LibCyberRadio::Driver::RadioHandler::getNbddcIndexRange
virtual BasicIntList getNbddcIndexRange() const
Gets the range of NBDDC indices on the radio.
Definition RadioHandler.cpp:1175
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepStepRange
virtual BasicDoubleList getTransmitterCWSweepStepRange() const
Gets the CW frequency step range.
Definition RadioHandler.cpp:1666
LibCyberRadio::Driver::RadioHandler::getNumWbddc
virtual int getNumWbddc() const
Gets the number of WBDDCs on the radio.
Definition RadioHandler.cpp:918
LibCyberRadio::Driver::RadioHandler::loadDucSnapshot
virtual bool loadDucSnapshot(int index, const std::string &filename, unsigned int startSample=0, unsigned int samples=0)
Load a snapshot file into a given DUC's memory block.
Definition RadioHandler.cpp:2079
LibCyberRadio::Driver::RadioHandler::sendCommand
virtual BasicStringList sendCommand(const std::string &cmdString, double timeout=-1)
Sends a command to the radio.
Definition RadioHandler.cpp:307
LibCyberRadio::Driver::RadioHandler::getWbddcDataPort
virtual int getWbddcDataPort(int index) const
Gets the data port for a given WBDDC.
Definition RadioHandler.cpp:1125
LibCyberRadio::Driver::RadioHandler::getByteOrder
virtual const char * getByteOrder() const
Gets the byte order (endianness) of the VITA 49.
Definition RadioHandler.cpp:755
LibCyberRadio::Driver::RadioHandler::isWbddcGroupEnabled
virtual bool isWbddcGroupEnabled(int index) const
Gets whether or not a given WBDDC group is enabled.
Definition RadioHandler.cpp:2123
LibCyberRadio::Driver::RadioHandler::getNbddcFrequencyRange
virtual BasicDoubleList getNbddcFrequencyRange() const
Gets the tunable frequency range for NBDDCs.
Definition RadioHandler.cpp:1183
LibCyberRadio::Driver::RadioHandler::setNbddcDataPort
virtual bool setNbddcDataPort(int index, int port)
Sets the data port for a given NBDDC.
Definition RadioHandler.cpp:1386
LibCyberRadio::Driver::RadioHandler::setTenGigFlowControlStatus
virtual bool setTenGigFlowControlStatus(bool enable)
Sets flow control status on all 10GigE data ports.
Definition RadioHandler.cpp:2300
LibCyberRadio::Driver::RadioHandler::enableDataPortErrors
virtual bool enableDataPortErrors(int index, bool enabled=true)
Enables errors on the data port.
Definition RadioHandler.cpp:2359
LibCyberRadio::Driver::RadioHandler::setWbddcSource
virtual bool setWbddcSource(int index, int source)
Sets the source (which tuner is supplying the signal) for a given WBDDC.
Definition RadioHandler.cpp:1044
LibCyberRadio::Driver::RadioHandler::getTunerAttenuation
virtual double getTunerAttenuation(int index) const
Gets the attenuation for a given tuner.
Definition RadioHandler.cpp:864
LibCyberRadio::Driver::RadioHandler::getNbddcFrequencyUnit
virtual double getNbddcFrequencyUnit() const
Gets the tuned frequency units for NBDDCs.
Definition RadioHandler.cpp:1201
LibCyberRadio::Driver::RadioHandler::getGpioOutput
virtual int getGpioOutput()
Gets the current GPIO output bits.
Definition RadioHandler.cpp:614
LibCyberRadio::Driver::RadioHandler::getNbddcRateList
virtual BasicDoubleList getNbddcRateList() const
Gets the list of allowed NBDDC sample rates, based on the rate set.
Definition RadioHandler.cpp:1219
LibCyberRadio::Driver::RadioHandler::getDucFrequency
virtual double getDucFrequency(int index) const
Gets the tuned frequency for a given DUC.
Definition RadioHandler.cpp:1926
LibCyberRadio::Driver::RadioHandler::getDucAttenuationRange
virtual BasicDoubleList getDucAttenuationRange() const
Gets the DUC attenuation range.
Definition RadioHandler.cpp:1989
LibCyberRadio::Driver::RadioHandler::disableWbddc
virtual bool disableWbddc(int index)
Disables a given WBDDC.
Definition RadioHandler.cpp:1012
LibCyberRadio::Driver::RadioHandler::getSimpleSourceMACAddress
virtual std::string getSimpleSourceMACAddress() const
Gets the source MAC address for radios without 10Gig data ports.
Definition RadioHandler.cpp:2498
LibCyberRadio::Driver::RadioHandler::getGpioOutputByIndex
virtual BasicIntList getGpioOutputByIndex(int index)
Gets the GPIO output settings for a given sequence index.
Definition RadioHandler.cpp:625
LibCyberRadio::Driver::RadioHandler::getTransmitterFrequency
virtual double getTransmitterFrequency(int index) const
Gets the frequency for a given transmitter.
Definition RadioHandler.cpp:1486
LibCyberRadio::Driver::RadioHandler::getTransmitterCWPhaseRes
virtual int getTransmitterCWPhaseRes() const
Gets the CW phase resolution.
Definition RadioHandler.cpp:1612
LibCyberRadio::Driver::RadioHandler::getTimeNextPps
virtual time_t getTimeNextPps()
Gets the time for the next PPS rising edge on the radio.
Definition RadioHandler.cpp:529
LibCyberRadio::Driver::RadioHandler::disableWbddcGroup
virtual bool disableWbddcGroup(int index)
Disables a given WBDDC group.
Definition RadioHandler.cpp:2141
LibCyberRadio::Driver::RadioHandler::initConfigurationDict
virtual void initConfigurationDict()
Initializes the configuration dictionary, defining the allowed keys.
Definition RadioHandler.cpp:2546
LibCyberRadio::Driver::RadioHandler::getVitaTailSize
virtual int getVitaTailSize() const
Gets the size of the VITA 49 tail.
Definition RadioHandler.cpp:735
LibCyberRadio::Driver::RadioHandler::setNbddcRateSet
virtual bool setNbddcRateSet(int index, const NbddcRateSet &set)
Sets the rate set for a given NBDDC.
Definition RadioHandler.cpp:1395
LibCyberRadio::Driver::RadioHandler::disableNbddcGroup
virtual bool disableNbddcGroup(int index)
Disables a given NBDDC group.
Definition RadioHandler.cpp:2231
LibCyberRadio::Driver::RadioHandler::enableTuner
virtual bool enableTuner(int index, bool enabled=true)
Enables a given tuner.
Definition RadioHandler.cpp:832
LibCyberRadio::Driver::RadioHandler::setTunerAttenuation
virtual bool setTunerAttenuation(int index, double atten)
Sets the attenuation for a given tuner.
Definition RadioHandler.cpp:873
LibCyberRadio::Driver::RadioHandler::setTunerFilter
virtual bool setTunerFilter(int index, int filter)
Sets the filter setting for a given tuner.
Definition RadioHandler.cpp:891
LibCyberRadio::Driver::RadioHandler::setNbddcGroupMembers
virtual bool setNbddcGroupMembers(int index, const BasicIntList &groupMembers)
Sets the list of group members for a given NBDDC group.
Definition RadioHandler.cpp:2263
LibCyberRadio::Driver::RadioHandler::setDucMode
virtual bool setDucMode(int index, int mode)
Sets the mode for a given DUC.
Definition RadioHandler.cpp:2052
LibCyberRadio::Driver::RadioHandler::getDucDataPort
virtual int getDucDataPort(int index) const
Gets the data port for a given DUC.
Definition RadioHandler.cpp:1908
LibCyberRadio::Driver::RadioHandler::getTransmitterCWNum
virtual int getTransmitterCWNum() const
Gets the number of CW tone generators associated with transmitters on this radio.
Definition RadioHandler.cpp:1549
LibCyberRadio::Driver::RadioHandler::getWbddcGroupMembers
virtual BasicIntList getWbddcGroupMembers(int index) const
Gets the list of group members for a given WBDDC group.
Definition RadioHandler.cpp:2164
LibCyberRadio::Driver::RadioHandler::getVersionInfo
virtual BasicStringStringDict getVersionInfo()
Gets version information for the radio.
Definition RadioHandler.cpp:250
LibCyberRadio::Driver::RadioHandler::getTunerFrequencyRange
virtual BasicDoubleList getTunerFrequencyRange() const
Gets the tunable frequency range.
Definition RadioHandler.cpp:778
LibCyberRadio::Driver::RadioHandler::getDucStreamId
virtual unsigned int getDucStreamId(int index) const
Gets the VITA 49 stream ID for a given DUC.
Definition RadioHandler.cpp:2061
LibCyberRadio::Driver::RadioHandler::setWbddcStreamId
virtual bool setWbddcStreamId(int index, unsigned int sid)
Sets the VITA 49 stream ID for a given WBDDC.
Definition RadioHandler.cpp:1116
LibCyberRadio::Driver::RadioHandler::getTransmitterCWAmplitudeRes
virtual double getTransmitterCWAmplitudeRes() const
Gets the CW amplitude resolution.
Definition RadioHandler.cpp:1594
LibCyberRadio::Driver::RadioHandler::getTstatus
virtual unsigned int getTstatus()
Gets the tuner status from the radio.
Definition RadioHandler.cpp:551
LibCyberRadio::Driver::RadioHandler::removeWbddcGroupMember
virtual bool removeWbddcGroupMember(int index, int member)
Removes a WBDDC from the given WBDDC group.
Definition RadioHandler.cpp:2191
LibCyberRadio::Driver::RadioHandler::isWbddcEnabled
virtual bool isWbddcEnabled(int index) const
Gets whether or not a given WBDDC is enabled.
Definition RadioHandler.cpp:994
LibCyberRadio::Driver::RadioHandler::getTunerAttenuationRange
virtual BasicDoubleList getTunerAttenuationRange() const
Gets the tuner attenuation range.
Definition RadioHandler.cpp:805
LibCyberRadio::Driver::RadioHandler::getAdcRate
virtual double getAdcRate() const
Gets the ADC sample rate.
Definition RadioHandler.cpp:720
LibCyberRadio::Driver::RadioHandler::getNbddcFrequencyRes
virtual double getNbddcFrequencyRes() const
Gets the tuned frequency resolution for NBDDCs.
Definition RadioHandler.cpp:1192
LibCyberRadio::Driver::RadioHandler::getWbddcStreamId
virtual unsigned int getWbddcStreamId(int index) const
Gets the VITA 49 stream ID for a given WBDDC.
Definition RadioHandler.cpp:1107
LibCyberRadio::Driver::RadioHandler::getTransmitterCWSweepDwellRange
virtual BasicDoubleList getTransmitterCWSweepDwellRange() const
Gets the CW dwell time range.
Definition RadioHandler.cpp:1684
LibCyberRadio::Driver::RadioHandler::getNbddcRateIndex
virtual int getNbddcRateIndex(int index) const
Gets the rate index for a given NBDDC.
Definition RadioHandler.cpp:1305
LibCyberRadio::Driver::RadioHandler::setNbddcGroupConfiguration
virtual bool setNbddcGroupConfiguration(int index, ConfigurationDict &cfg)
Sets the configuration dictionary for a given NBDDC group.
Definition RadioHandler.cpp:2245
LibCyberRadio::Driver::RadioHandler::enableDuc
virtual bool enableDuc(int index, bool enabled)
Enables a given DUC.
Definition RadioHandler.cpp:1876
LibCyberRadio::Driver::RadioHandler::getTransmitterCWConfiguration
virtual ConfigurationDict getTransmitterCWConfiguration(int index, int cwIndex) const
Gets the configuration for a given CW tone generator.
Definition RadioHandler.cpp:1716
LibCyberRadio::Driver::RadioHandler::getTransmitterConfiguration
virtual ConfigurationDict getTransmitterConfiguration(int index) const
Gets the configuration dictionary for a given transmitter.
Definition RadioHandler.cpp:1522
LibCyberRadio::Driver::RadioHandler::getDefaultDeviceInfo
virtual int getDefaultDeviceInfo() const
Gets the default device information.
Definition RadioHandler.cpp:2540
LibCyberRadio::Driver::RadioHandler::getNbddcSource
virtual int getNbddcSource(int index) const
Gets the source (which tuner is supplying the signal) for a given NBDDC.
Definition RadioHandler.cpp:1287
LibCyberRadio::Driver::RadioHandler::setCalibrationFrequency
virtual bool setCalibrationFrequency(double freq)
Sets the calibration frequency.
Definition RadioHandler.cpp:667
LibCyberRadio::Driver::RadioHandler::sendReset
virtual bool sendReset(int resetType=0)
Resets the radio.
Definition RadioHandler.cpp:468
LibCyberRadio::Driver::RadioHandler::getTransmitterCWPhaseRange
virtual BasicDoubleList getTransmitterCWPhaseRange() const
Gets the CW phase range.
Definition RadioHandler.cpp:1603
LibCyberRadio::Driver::RadioHandler::~RadioHandler
virtual ~RadioHandler()
Destroys a RadioHandler object.
Definition RadioHandler.cpp:101
LibCyberRadio::Driver::RadioHandler::getTransmitterAttenuation
virtual double getTransmitterAttenuation(int index) const
Gets the attenuation for a given transmitter.
Definition RadioHandler.cpp:1504
LibCyberRadio::Driver::RadioHandler::enableNbddc
virtual bool enableNbddc(int index, bool enabled=true)
Enables a given NBDDC.
Definition RadioHandler.cpp:1237
LibCyberRadio::Driver::RadioHandler::getWbddcRateList
virtual BasicDoubleList getWbddcRateList() const
Gets the list of allowed WBDDC sample rates, based on the rate set.
Definition RadioHandler.cpp:985
LibCyberRadio::Driver::RadioHandler::disableDuc
virtual bool disableDuc(int index)
Disables a given DUC.
Definition RadioHandler.cpp:1885
LibCyberRadio::Driver::RadioHandler::getTenGigFlowControlStatus
virtual BasicIntBoolDict getTenGigFlowControlStatus()
Gets flow control status on all 10GigE data ports.
Definition RadioHandler.cpp:2311
LibCyberRadio::Driver::RadioHandler::getTransmitterCWAmplitudeRange
virtual BasicDoubleList getTransmitterCWAmplitudeRange() const
Gets the CW amplitude range.
Definition RadioHandler.cpp:1585
LibCyberRadio::Driver::VitaIfSpec
Class that defines the VITA interface specification for an NDR-class radio.
Definition VitaIfSpec.h:34
LibCyberRadio::Pythonesque::Strip
static std::string Strip(const std::string &str, const std::string &chars=" \r\n\t\v\f")
Strips both leading and trailing whitespace from the given string.
Definition Pythonesque.cpp:57
LibCyberRadio::Pythonesque::Split
static BasicStringList Split(const std::string &str, const std::string &sep, int maxsplit=INT_MAX)
Splits the given string into a list of string tokens.
Definition Pythonesque.cpp:77
LibCyberRadio::Pythonesque::Replace
static std::string Replace(const std::string &str, const std::string &oldstr, const std::string &newstr, int count=INT_MAX)
Replaces occurrences of one substring with another within the given string.
Definition Pythonesque.cpp:62
LibCyberRadio::Driver
Provides programming elements for driving CRS NDR-class radios.
Definition ConfigString.h:27
LibCyberRadio::Driver::NbddcRateSet
BASIC_DICT_CONTAINER< int, double > NbddcRateSet
A rate set for a NBDDC.
Definition NbddcComponent.h:36
LibCyberRadio::Driver::DucRateSet
BASIC_DICT_CONTAINER< int, double > DucRateSet
A rate set for a DUC.
Definition DucComponent.h:36
LibCyberRadio::Driver::WbddcRateSet
BASIC_DICT_CONTAINER< int, double > WbddcRateSet
A rate set for a WBDDC.
Definition WbddcComponent.h:36
LibCyberRadio
Defines functionality for LibCyberRadio applications.
Definition App.h:24
LibCyberRadio::BasicIntList
BASIC_LIST_CONTAINER< int > BasicIntList
Type representing a list of integers.
Definition BasicList.h:27
LibCyberRadio::BasicStringStringDict
BASIC_DICT_CONTAINER< std::string, std::string > BasicStringStringDict
Type representing a dictionary of strings, keyed by string values.
Definition BasicDict.h:27
LibCyberRadio::BasicDoubleList
BASIC_LIST_CONTAINER< double > BasicDoubleList
Type representing a list of doubles.
Definition BasicList.h:29
LibCyberRadio::BasicStringList
BASIC_LIST_CONTAINER< std::string > BasicStringList
Type representing a list of strings.
Definition BasicList.h:25
LibCyberRadio::BasicIntBoolDict
BASIC_DICT_CONTAINER< int, bool > BasicIntBoolDict
Type representing a dictionary of Boolean values, keyed by integers.
Definition BasicDict.h:37