libcyberradio 22.01.24
CWToneGenComponent.cpp
1/***************************************************************************
2 * \file CWToneGenComponent.cpp
3 * \brief Defines the basic continuous-wave (CW) tone generator interface
4 * for an NDR-class radio.
5 * \author DA
6 * \author NH
7 * \author MN
8 * \copyright (c) 2017 CyberRadio Solutions, Inc. All rights reserved.
9 *
10 ***************************************************************************/
11
12#include "LibCyberRadio/Driver/CWToneGenComponent.h"
13#include "LibCyberRadio/Driver/RadioHandler.h"
14#include "LibCyberRadio/Common/Pythonesque.h"
15#include <boost/lexical_cast.hpp>
16#include <sstream>
17#include <iomanip>
18#include <string>
19
20
21namespace LibCyberRadio
22{
23
24 namespace Driver
25 {
26
27 CWToneGenComponent::CWToneGenComponent(
28 const std::string& name,
29 int index,
30 RadioHandler* parent,
31 bool debug,
32 int txIndex,
33 double freqRangeMin,
34 double freqRangeMax,
35 double freqRes,
36 double freqUnits,
37 double ampRangeMin,
38 double ampRangeMax,
39 double ampRes,
40 double phaseRangeMin,
41 double phaseRangeMax,
42 double phaseRes,
43 double sweepStartRangeMin,
44 double sweepStartRangeMax,
45 double sweepStartRes,
46 double sweepStopRangeMin,
47 double sweepStopRangeMax,
48 double sweepStopRes,
49 double sweepStepRangeMin,
50 double sweepStepRangeMax,
51 double sweepStepRes,
52 double dwellTimeRangeMin,
53 double dwellTimeRangeMax,
54 double dwellTimeRes,
55 double frequency,
56 double amplitude,
57 double phase,
58 double sweepStart,
59 double sweepStop,
60 double sweepStep,
61 double dwellTime
62 ) :
63 RadioComponent(name, index, parent, debug),
64 _txIndex(txIndex),
65 _freqRangeMin(freqRangeMin),
66 _freqRangeMax(freqRangeMax),
67 _freqRes(freqRes),
68 _freqUnits(freqUnits),
69 _ampRangeMin(ampRangeMin),
70 _ampRangeMax(ampRangeMax),
71 _ampRes(ampRes),
72 _phaseRangeMin(phaseRangeMin),
73 _phaseRangeMax(phaseRangeMax),
74 _phaseRes(phaseRes),
75 _sweepStartRangeMin(sweepStartRangeMin),
76 _sweepStartRangeMax(sweepStartRangeMax),
77 _sweepStartRes(sweepStartRes),
78 _sweepStopRangeMin(sweepStopRangeMin),
79 _sweepStopRangeMax(sweepStopRangeMax),
80 _sweepStopRes(sweepStopRes),
81 _sweepStepRangeMin(sweepStepRangeMin),
82 _sweepStepRangeMax(sweepStepRangeMax),
83 _sweepStepRes(sweepStepRes),
84 _dwellTimeRangeMin(dwellTimeRangeMin),
85 _dwellTimeRangeMax(dwellTimeRangeMax),
86 _dwellTimeRes(dwellTimeRes),
87 _frequency(frequency),
88 _amplitude(amplitude),
89 _phase(phase),
90 _sweepStart(sweepStart),
91 _sweepStop(sweepStop),
92 _sweepStep(sweepStep),
93 _dwellTime(dwellTime)
94 {
95 // Call init function
96 initConfigurationDict();
97 }
98
103
104 CWToneGenComponent::CWToneGenComponent(const CWToneGenComponent& other) :
105 RadioComponent(other),
106 _txIndex(other._txIndex),
107 _freqRangeMin(other._freqRangeMin),
108 _freqRangeMax(other._freqRangeMax),
109 _freqRes(other._freqRes),
110 _freqUnits(other._freqUnits),
111 _ampRangeMin(other._ampRangeMin),
112 _ampRangeMax(other._ampRangeMax),
113 _ampRes(other._ampRes),
114 _phaseRangeMin(other._phaseRangeMin),
115 _phaseRangeMax(other._phaseRangeMax),
116 _phaseRes(other._phaseRes),
117 _sweepStartRangeMin(other._sweepStartRangeMin),
118 _sweepStartRangeMax(other._sweepStartRangeMax),
119 _sweepStartRes(other._sweepStartRes),
120 _sweepStopRangeMin(other._sweepStopRangeMin),
121 _sweepStopRangeMax(other._sweepStopRangeMax),
122 _sweepStopRes(other._sweepStopRes),
123 _sweepStepRangeMin(other._sweepStepRangeMin),
124 _sweepStepRangeMax(other._sweepStepRangeMax),
125 _sweepStepRes(other._sweepStepRes),
126 _dwellTimeRangeMin(other._dwellTimeRangeMin),
127 _dwellTimeRangeMax(other._dwellTimeRangeMax),
128 _dwellTimeRes(other._dwellTimeRes),
129 _frequency(other._frequency),
130 _amplitude(other._amplitude),
131 _phase(other._phase),
132 _sweepStart(other._sweepStart),
133 _sweepStop(other._sweepStop),
134 _sweepStep(other._sweepStep),
135 _dwellTime(other._dwellTime)
136 {
137
138 }
139
140 CWToneGenComponent& CWToneGenComponent::operator=(const CWToneGenComponent& other)
141 {
142 RadioComponent::operator=(other);
143 if ( this != &other )
144 {
145 _txIndex = other._txIndex;
146 _freqRangeMin = other._freqRangeMin;
147 _freqRangeMax = other._freqRangeMax;
148 _freqRes = other._freqRes;
149 _freqUnits = other._freqUnits;
150 _ampRangeMin = other._ampRangeMin;
151 _ampRangeMax = other._ampRangeMax;
152 _ampRes = other._ampRes;
153 _phaseRangeMin = other._phaseRangeMin;
154 _phaseRangeMax = other._phaseRangeMax;
155 _phaseRes = other._phaseRes;
156 _sweepStartRangeMin = other._sweepStartRangeMin;
157 _sweepStartRangeMax = other._sweepStartRangeMax;
158 _sweepStartRes = other._sweepStartRes;
159 _sweepStopRangeMin = other._sweepStopRangeMin;
160 _sweepStopRangeMax = other._sweepStopRangeMax;
161 _sweepStopRes = other._sweepStopRes;
162 _sweepStepRangeMin = other._sweepStepRangeMin;
163 _sweepStepRangeMax = other._sweepStepRangeMax;
164 _sweepStepRes = other._sweepStepRes;
165 _dwellTimeRangeMin = other._dwellTimeRangeMin;
166 _dwellTimeRangeMax = other._dwellTimeRangeMax;
167 _dwellTimeRes = other._dwellTimeRes;
168 _frequency = other._frequency;
169 _amplitude = other._amplitude;
170 _phase = other._phase;
171 _sweepStart = other._sweepStart;
172 _sweepStop = other._sweepStop;
173 _sweepStep = other._sweepStep;
174 _dwellTime = other._dwellTime;
175 }
176 return *this;
177 }
178
179 bool CWToneGenComponent::enable(bool enabled)
180 {
181 return setAmplitude(enabled ? _amplitude : 0);
182 }
183
184 bool CWToneGenComponent::setConfiguration(ConfigurationDict& cfg)
185 {
186 this->debug("[CWToneGenComponent::setConfiguration] Called\n");
187 // Call the "grandparent" version of this method instead of the
188 // parent version. We want the normalization, but not the
189 // automatic enabling.
190 bool ret = Configurable::setConfiguration(cfg);
191 // Use the keys provided in the *incoming* dictionary to determine
192 // what needs to be changed via hardware calls.
193 double adjFrequency = _frequency;
194 double adjAmplitude = _amplitude;
195 double adjPhase = _phase;
196 double adjStart = _sweepStart;
197 double adjStop = _sweepStop;
198 double adjStep = _sweepStep;
199 double adjDwell = _dwellTime;
200 bool adjEnabled = _enabled;
201 bool toneCmdNeedsExecuting = false;
202 bool sweepCmdNeedsExecuting = false;
203 if ( cfg.hasKey("enable") && _config.hasKey("enable") )
204 {
205 adjEnabled = getConfigurationValueAsBool("enable");
206 toneCmdNeedsExecuting = true;
207 }
208 if ( cfg.hasKey("cwFrequency") && _config.hasKey("cwFrequency") )
209 {
210 adjFrequency = getConfigurationValueAsDbl("cwFrequency");
211 toneCmdNeedsExecuting = true;
212 }
213 if ( cfg.hasKey("cwAmplitude") && _config.hasKey("cwAmplitude") )
214 {
215 adjAmplitude = getConfigurationValueAsInt("cwAmplitude");
216 toneCmdNeedsExecuting = true;
217 }
218 if ( cfg.hasKey("cwPhase") && _config.hasKey("cwPhase") )
219 {
220 adjPhase = getConfigurationValueAsInt("cwPhase");
221 toneCmdNeedsExecuting = true;
222 }
223 if ( cfg.hasKey("cwSweepStart") && _config.hasKey("cwSweepStart") )
224 {
225 adjStart = getConfigurationValueAsDbl("cwSweepStart");
226 sweepCmdNeedsExecuting = true;
227 }
228 if ( cfg.hasKey("cwSweepStop") && _config.hasKey("cwSweepStop") )
229 {
230 adjStop = getConfigurationValueAsDbl("cwSweepStop");
231 sweepCmdNeedsExecuting = true;
232 }
233 if ( cfg.hasKey("cwSweepStep") && _config.hasKey("cwSweepStep") )
234 {
235 adjStep = getConfigurationValueAsDbl("cwSweepStep");
236 sweepCmdNeedsExecuting = true;
237 }
238 if ( cfg.hasKey("cwSweepDwell") && _config.hasKey("cwSweepDwell") )
239 {
240 adjDwell = getConfigurationValueAsInt("cwSweepDwell");
241 sweepCmdNeedsExecuting = true;
242 }
243 if ( toneCmdNeedsExecuting )
244 {
245 ret &= executeToneCommand(_index, _txIndex, adjFrequency, adjAmplitude,
246 adjPhase);
247 }
248 if ( sweepCmdNeedsExecuting )
249 {
250 ret &= executeSweepCommand(_index, _txIndex, adjStart, adjStop,
251 adjStep, adjDwell);
252 }
253 if ( ret )
254 {
255 _enabled = adjEnabled;
256 _frequency = adjFrequency;
257 _amplitude = adjAmplitude;
258 _phase = adjPhase;
259 _sweepStart = adjStart;
260 _sweepStop = adjStop;
261 _sweepStep = adjStep;
262 _dwellTime = adjDwell;
263 updateConfigurationDict();
264 }
265 this->debug("[CWToneGenComponent::setConfiguration] Returning\n");
266 return ret;
267 }
268
269 void CWToneGenComponent::queryConfiguration()
270 {
271 this->debug("[CWToneGenComponent::queryConfiguration] Called\n");
272 if ( _config.hasKey("cwFrequency") &&
273 _config.hasKey("cwAmplitude") &&
274 _config.hasKey("cwPhase") )
275 {
276 executeToneQuery(_index, _txIndex, _frequency, _amplitude, _phase);
277 }
278 if ( _config.hasKey("cwSweepStart") &&
279 _config.hasKey("cwSweepStop") &&
280 _config.hasKey("cwSweepStep") &&
281 _config.hasKey("cwSweepDwell") )
282 {
283 executeSweepQuery(_index, _txIndex, _sweepStart, _sweepStop, _sweepStep,
284 _dwellTime);
285 }
286 _enabled = (_amplitude != 0);
287 updateConfigurationDict();
288 this->debug("[CWToneGenComponent::queryConfiguration] Returning\n");
289 }
290
291 BasicDoubleList CWToneGenComponent::getFrequencyRange() const
292 {
293 BasicDoubleList ret;
294 ret.push_back(_freqRangeMin);
295 ret.push_back(_freqRangeMax);
296 return ret;
297 }
298
299 double CWToneGenComponent::getFrequencyRes() const
300 {
301 return _freqRes;
302 }
303
304 BasicDoubleList CWToneGenComponent::getAmplitudeRange() const
305 {
306 BasicDoubleList ret;
307 ret.push_back(_ampRangeMin);
308 ret.push_back(_ampRangeMax);
309 return ret;
310 }
311
312 double CWToneGenComponent::getAmplitudeRes() const
313 {
314 return _ampRes;
315 }
316
317 BasicDoubleList CWToneGenComponent::getPhaseRange() const
318 {
319 BasicDoubleList ret;
320 ret.push_back(_phaseRangeMin);
321 ret.push_back(_phaseRangeMax);
322 return ret;
323 }
324
325 double CWToneGenComponent::getPhaseRes() const
326 {
327 return _phaseRes;
328 }
329
330 BasicDoubleList CWToneGenComponent::getSweepStartRange() const
331 {
332 BasicDoubleList ret;
333 ret.push_back(_sweepStartRangeMin);
334 ret.push_back(_sweepStartRangeMax);
335 return ret;
336 }
337
338 double CWToneGenComponent::getSweepStartRes() const
339 {
340 return _sweepStartRes;
341 }
342
343 BasicDoubleList CWToneGenComponent::getSweepStopRange() const
344 {
345 BasicDoubleList ret;
346 ret.push_back(_sweepStopRangeMin);
347 ret.push_back(_sweepStopRangeMax);
348 return ret;
349 }
350
351 double CWToneGenComponent::getSweepStopRes() const
352 {
353 return _sweepStopRes;
354 }
355
356 BasicDoubleList CWToneGenComponent::getSweepStepRange() const
357 {
358 BasicDoubleList ret;
359 ret.push_back(_sweepStepRangeMin);
360 ret.push_back(_sweepStepRangeMax);
361 return ret;
362 }
363
364 double CWToneGenComponent::getSweepStepRes() const
365 {
366 return _sweepStepRes;
367 }
368
369 BasicDoubleList CWToneGenComponent::getDwellTimeRange() const
370 {
371 BasicDoubleList ret;
372 ret.push_back(_dwellTimeRangeMin);
373 ret.push_back(_dwellTimeRangeMax);
374 return ret;
375 }
376
377 double CWToneGenComponent::getDwellTimeRes() const
378 {
379 return _dwellTimeRes;
380 }
381
382 double CWToneGenComponent::getFrequency() const
383 {
384 return _frequency;
385 }
386
387 bool CWToneGenComponent::setFrequency(double freq)
388 {
389 bool ret = false;
390 if ( _config.hasKey("frequency") )
391 {
392 double adjFrequency = freq;
393 double adjAmplitude = _amplitude;
394 double adjPhase = _phase;
395 ret = executeToneCommand(_index, _txIndex, adjFrequency, adjAmplitude, adjPhase);
396 if ( ret )
397 {
398 _frequency = adjFrequency;
399 updateConfigurationDict();
400 }
401 }
402 return ret;
403 }
404
405 double CWToneGenComponent::getAmplitude() const
406 {
407 return _amplitude;
408 }
409
410 bool CWToneGenComponent::setAmplitude(double amp)
411 {
412 bool ret = false;
413 if ( _config.hasKey("cwAmplitude") )
414 {
415 double adjFrequency = _frequency;
416 double adjAmplitude = amp;
417 double adjPhase = _phase;
418 ret = executeToneCommand(_index, _txIndex, adjFrequency, adjAmplitude, adjPhase);
419 if ( ret )
420 {
421 _amplitude = adjAmplitude;
422 _enabled = (_amplitude != 0);
423 updateConfigurationDict();
424 }
425 }
426 return ret;
427 }
428
429 double CWToneGenComponent::getPhase() const
430 {
431 return _phase;
432 }
433
434 bool CWToneGenComponent::setPhase(double phase)
435 {
436 bool ret = false;
437 if ( _config.hasKey("cwPhase") )
438 {
439 double adjFrequency = _frequency;
440 double adjAmplitude = _amplitude;
441 double adjPhase = phase;
442 ret = executeToneCommand(_index, _txIndex, adjFrequency, adjAmplitude, adjPhase);
443 if ( ret )
444 {
445 _phase = adjPhase;
446 updateConfigurationDict();
447 }
448 }
449 return ret;
450 }
451
452 bool CWToneGenComponent::supportsSweep() const
453 {
454 bool ret = ( _sweepStartRangeMin != _sweepStartRangeMax );
455 return ret;
456 }
457
458 double CWToneGenComponent::getSweepStartFrequency() const
459 {
460 return _sweepStart;
461 }
462
463 double CWToneGenComponent::getSweepStopFrequency() const
464 {
465 return _sweepStop;
466 }
467
468 double CWToneGenComponent::getSweepFrequencyStep() const
469 {
470 return _sweepStep;
471 }
472
473 double CWToneGenComponent::getSweepDwellTime() const
474 {
475 return _dwellTime;
476 }
477
478 bool CWToneGenComponent::setFrequencySweep(double start, double stop,
479 double step, double dwell)
480 {
481 bool ret = false;
482 if ( _config.hasKey("cwSweepStart") &&
483 _config.hasKey("cwSweepStop") &&
484 _config.hasKey("cwSweepStep") &&
485 _config.hasKey("cwSweepDwell") )
486 {
487 double adjStart = start;
488 double adjStop = stop;
489 double adjStep = step;
490 double adjDwell = dwell;
491 ret = executeSweepCommand(_index, _txIndex, adjStart, adjStop, adjStep,
492 adjDwell);
493 if ( ret )
494 {
495 _sweepStart = adjStart;
496 _sweepStop = adjStop;
497 _sweepStep = adjStep;
498 _dwellTime = adjDwell;
499 updateConfigurationDict();
500 }
501 }
502 return ret;
503 }
504
505 void CWToneGenComponent::initConfigurationDict()
506 {
507 //this->debug("[CWToneGenComponent::initConfigurationDict] Called\n");
508 _config.clear();
509 // Call the base-class version
510 RadioComponent::initConfigurationDict();
511 // Define tone generator-specific keys
512 _config["cwFrequency"] = "0";
513 _config["cwAmplitude"] = "0";
514 _config["cwPhase"] = "0";
515 _config["cwSweepStart"] = "0";
516 _config["cwSweepStop"] = "0";
517 _config["cwSweepStep"] = "0";
518 _config["cwSweepDwell"] = "0";
519 //this->debug("[CWToneGenComponent::initConfigurationDict] Returning\n");
520 }
521
522 void CWToneGenComponent::updateConfigurationDict()
523 {
524 this->debug("[CWToneGenComponent::updateConfigurationDict] Called\n");
525 RadioComponent::updateConfigurationDict();
526 if ( _config.hasKey("cwFrequency") )
527 setConfigurationValueToDbl("cwFrequency", _frequency);
528 if ( _config.hasKey("cwAmplitude") )
529 setConfigurationValueToDbl("cwAmplitude", _amplitude);
530 if ( _config.hasKey("cwPhase") )
531 setConfigurationValueToDbl("cwPhase", _phase);
532 if ( _config.hasKey("cwSweepStart") )
533 setConfigurationValueToDbl("cwSweepStart", _sweepStart);
534 if ( _config.hasKey("cwSweepStop") )
535 setConfigurationValueToDbl("cwSweepStop", _sweepStop);
536 if ( _config.hasKey("cwSweepStep") )
537 setConfigurationValueToDbl("cwSweepStep", _sweepStep);
538 if ( _config.hasKey("cwSweepDwell") )
539 setConfigurationValueToDbl("cwSweepDwell", _dwellTime);
540 this->debug("[CWToneGenComponent::updateConfigurationDict] Returning\n");
541 }
542
543 // CW tone query uses the NDR651 implementation as the base
544 bool CWToneGenComponent::executeToneQuery(int index,
545 int txIndex,
546 double& freq,
547 double& amp,
548 double& phase)
549 {
550 bool ret = false;
551 if ( (_parent != NULL) && (_parent->isConnected()) )
552 {
553 std::ostringstream oss;
554 oss << "CWT? " << txIndex << ", " << index << "\n";
555 BasicStringList rsp = _parent->sendCommand(oss.str(), 2.0);
556 if ( _parent->getLastCommandErrorInfo() == "" )
557 {
558 BasicStringList vec = Pythonesque::Split(
559 Pythonesque::Replace(rsp.front(), "CWT ", ""),
560 ", ");
561 // vec[0] = TX Index
562 // vec[1] = CWTG Index
563 // vec[2] = Frequency (Hz)
564 freq = boost::lexical_cast<double>(vec[2]);
565 // vec[3] = Amplitude
566 amp = boost::lexical_cast<double>(vec[3]);
567 // vec[4] = Phase (deg)
568 phase = boost::lexical_cast<double>(vec[4]);
569 ret = true;
570 }
571 }
572 return ret;
573 }
574
575 // CW tone command uses the NDR651 implementation as the base
576 bool CWToneGenComponent::executeToneCommand(int index,
577 int txIndex,
578 double& freq,
579 double& amp,
580 double& phase)
581 {
582 bool ret = false;
583 if ( (_parent != NULL) && (_parent->isConnected()) )
584 {
585 std::ostringstream oss;
586 oss << "CWT " << txIndex
587 << ", " << index
588 << ", " << std::setprecision(1) << std::fixed << freq
589 << ", " << std::setprecision(1) << std::fixed << amp
590 << ", " << std::setprecision(1) << std::fixed << phase
591 << "\n";
592 BasicStringList rsp = _parent->sendCommand(oss.str(), 2.0);
593 if ( _parent->getLastCommandErrorInfo() == "" )
594 {
595 ret = true;
596 }
597 }
598 return ret;
599 }
600
601 // CW sweep query uses the NDR651 implementation as the base
602 bool CWToneGenComponent::executeSweepQuery(int index,
603 int txIndex,
604 double& sweepStart,
605 double& sweepStop,
606 double& sweepStep,
607 double& dwellTime)
608 {
609 bool ret = false;
610 if ( (_parent != NULL) && (_parent->isConnected()) )
611 {
612 std::ostringstream oss;
613 oss << "CWS? " << txIndex << ", " << index << "\n";
614 BasicStringList rsp = _parent->sendCommand(oss.str(), 2.0);
615 if ( _parent->getLastCommandErrorInfo() == "" )
616 {
617 BasicStringList vec = Pythonesque::Split(
618 Pythonesque::Replace(rsp.front(), "CWS ", ""),
619 ", ");
620 // vec[0] = TX Index
621 // vec[1] = CWTG Index
622 // vec[2] = Start frequency (Hz)
623 sweepStart = boost::lexical_cast<double>(vec[2]);
624 // vec[3] = Stop frequency (Hz)
625 sweepStop = boost::lexical_cast<double>(vec[3]);
626 // vec[4] = Frequency step (Hz)
627 sweepStep = boost::lexical_cast<double>(vec[4]);
628 // vec[5] = Dwell time (sample clocks)
629 dwellTime = boost::lexical_cast<double>(vec[5]);
630 ret = true;
631 }
632 }
633 return ret;
634 }
635
636 // CW sweep command uses the NDR651 implementation as the base
637 bool CWToneGenComponent::executeSweepCommand(int index,
638 int txIndex,
639 double& sweepStart,
640 double& sweepStop,
641 double& sweepStep,
642 double& dwellTime)
643 {
644 bool ret = false;
645 if ( (_parent != NULL) && (_parent->isConnected()) )
646 {
647 std::ostringstream oss;
648 oss << "CWS " << txIndex
649 << ", " << index
650 << ", " << std::setprecision(1) << std::fixed << sweepStart
651 << ", " << std::setprecision(1) << std::fixed << sweepStop
652 << ", " << std::setprecision(1) << std::fixed << sweepStep
653 << ", " << std::setprecision(1) << std::fixed << dwellTime
654 << "\n";
655 BasicStringList rsp = _parent->sendCommand(oss.str(), 2.0);
656 if ( _parent->getLastCommandErrorInfo() == "" )
657 {
658 ret = true;
659 }
660 }
661 return ret;
662 }
663
664
665 } // namespace Driver
666
667} // namespace LibCyberRadio
668
669
670
671
672
LibCyberRadio::Debuggable::debug
virtual int debug(const char *format,...)
Outputs debug information.
Definition Debuggable.cpp:95
LibCyberRadio::Driver::CWToneGenComponent::getSweepStepRes
virtual double getSweepStepRes() const
Gets the sweep step resolution.
Definition CWToneGenComponent.cpp:364
LibCyberRadio::Driver::CWToneGenComponent::enable
virtual bool enable(bool enabled=true)
Enables this component.
Definition CWToneGenComponent.cpp:179
LibCyberRadio::Driver::CWToneGenComponent::operator=
virtual CWToneGenComponent & operator=(const CWToneGenComponent &other)
Assignment operator for CWToneGenComponent objects.
Definition CWToneGenComponent.cpp:140
LibCyberRadio::Driver::CWToneGenComponent::setConfiguration
virtual bool setConfiguration(ConfigurationDict &cfg)
Sets the configuration dictionary for this component.
Definition CWToneGenComponent.cpp:184
LibCyberRadio::Driver::CWToneGenComponent::getSweepStartFrequency
virtual double getSweepStartFrequency() const
Gets the start frequency for a signal sweep.
Definition CWToneGenComponent.cpp:458
LibCyberRadio::Driver::CWToneGenComponent::getSweepStopRange
virtual BasicDoubleList getSweepStopRange() const
Gets the sweep stop range.
Definition CWToneGenComponent.cpp:343
LibCyberRadio::Driver::CWToneGenComponent::getAmplitudeRes
virtual double getAmplitudeRes() const
Gets the amplitude resolution.
Definition CWToneGenComponent.cpp:312
LibCyberRadio::Driver::CWToneGenComponent::getSweepDwellTime
virtual double getSweepDwellTime() const
Gets the dwell time for a signal sweep.
Definition CWToneGenComponent.cpp:473
LibCyberRadio::Driver::CWToneGenComponent::getFrequencyRange
virtual BasicDoubleList getFrequencyRange() const
Gets the frequency range.
Definition CWToneGenComponent.cpp:291
LibCyberRadio::Driver::CWToneGenComponent::setPhase
virtual bool setPhase(double phase)
Sets the signal phase.
Definition CWToneGenComponent.cpp:434
LibCyberRadio::Driver::CWToneGenComponent::getSweepStopRes
virtual double getSweepStopRes() const
Gets the sweep stop resolution.
Definition CWToneGenComponent.cpp:351
LibCyberRadio::Driver::CWToneGenComponent::setFrequency
virtual bool setFrequency(double freq)
Sets the constant frequency.
Definition CWToneGenComponent.cpp:387
LibCyberRadio::Driver::CWToneGenComponent::getSweepStartRange
virtual BasicDoubleList getSweepStartRange() const
Gets the sweep start range.
Definition CWToneGenComponent.cpp:330
LibCyberRadio::Driver::CWToneGenComponent::supportsSweep
virtual bool supportsSweep() const
Gets whether or not the generator supports signal sweeps.
Definition CWToneGenComponent.cpp:452
LibCyberRadio::Driver::CWToneGenComponent::getFrequency
virtual double getFrequency() const
Gets the constant frequency.
Definition CWToneGenComponent.cpp:382
LibCyberRadio::Driver::CWToneGenComponent::setFrequencySweep
virtual bool setFrequencySweep(double start, double stop, double step, double dwell)
Sets the parameters for a frequency sweep.
Definition CWToneGenComponent.cpp:478
LibCyberRadio::Driver::CWToneGenComponent::CWToneGenComponent
CWToneGenComponent(const std::string &name="CWTONE", int index=0, RadioHandler *parent=NULL, bool debug=false, int txIndex=0, double freqRangeMin=0.0, double freqRangeMax=0.0, double freqRes=0.0, double freqUnits=0.0, double ampRangeMin=0.0, double ampRangeMax=0.0, double ampRes=0.0, double phaseRangeMin=0.0, double phaseRangeMax=0.0, double phaseRes=0.0, double sweepStartRangeMin=0.0, double sweepStartRangeMax=0.0, double sweepStartRes=0.0, double sweepStopRangeMin=0.0, double sweepStopRangeMax=0.0, double sweepStopRes=0.0, double sweepStepRangeMin=0.0, double sweepStepRangeMax=0.0, double sweepStepRes=0.0, double dwellTimeRangeMin=0.0, double dwellTimeRangeMax=0.0, double dwellTimeRes=0.0, double frequency=0.0, double amplitude=0.0, double phase=0.0, double sweepStart=0.0, double sweepStop=0.0, double sweepStep=0.0, double dwellTime=0.0)
Constructs a CWToneGenComponent object.
Definition CWToneGenComponent.cpp:27
LibCyberRadio::Driver::CWToneGenComponent::getDwellTimeRange
virtual BasicDoubleList getDwellTimeRange() const
Gets the dwell time range.
Definition CWToneGenComponent.cpp:369
LibCyberRadio::Driver::CWToneGenComponent::setAmplitude
virtual bool setAmplitude(double amp)
Sets the signal amplitude.
Definition CWToneGenComponent.cpp:410
LibCyberRadio::Driver::CWToneGenComponent::executeToneCommand
virtual bool executeToneCommand(int index, int txIndex, double &freq, double &amp, double &phase)
Executes the CW tone set command.
Definition CWToneGenComponent.cpp:576
LibCyberRadio::Driver::CWToneGenComponent::getPhaseRes
virtual double getPhaseRes() const
Gets the phase resolution.
Definition CWToneGenComponent.cpp:325
LibCyberRadio::Driver::CWToneGenComponent::executeSweepQuery
virtual bool executeSweepQuery(int index, int txIndex, double &sweepStart, double &sweepStop, double &sweepStep, double &dwellTime)
Executes the CW sweep query command.
Definition CWToneGenComponent.cpp:602
LibCyberRadio::Driver::CWToneGenComponent::getSweepStopFrequency
virtual double getSweepStopFrequency() const
Gets the stop frequency for a signal sweep.
Definition CWToneGenComponent.cpp:463
LibCyberRadio::Driver::CWToneGenComponent::executeToneQuery
virtual bool executeToneQuery(int index, int txIndex, double &freq, double &amp, double &phase)
Executes the CW tone query command.
Definition CWToneGenComponent.cpp:544
LibCyberRadio::Driver::CWToneGenComponent::getDwellTimeRes
virtual double getDwellTimeRes() const
Gets the dwell time resolution.
Definition CWToneGenComponent.cpp:377
LibCyberRadio::Driver::CWToneGenComponent::queryConfiguration
virtual void queryConfiguration()
Tells the component to query its hardware configuration in order to create its configuration dictiona...
Definition CWToneGenComponent.cpp:269
LibCyberRadio::Driver::CWToneGenComponent::getSweepFrequencyStep
virtual double getSweepFrequencyStep() const
Gets the frequency step for a signal sweep.
Definition CWToneGenComponent.cpp:468
LibCyberRadio::Driver::CWToneGenComponent::getAmplitudeRange
virtual BasicDoubleList getAmplitudeRange() const
Gets the amplitude range.
Definition CWToneGenComponent.cpp:304
LibCyberRadio::Driver::CWToneGenComponent::getPhase
virtual double getPhase() const
Gets the signal phase.
Definition CWToneGenComponent.cpp:429
LibCyberRadio::Driver::CWToneGenComponent::getSweepStepRange
virtual BasicDoubleList getSweepStepRange() const
Gets the sweep step range.
Definition CWToneGenComponent.cpp:356
LibCyberRadio::Driver::CWToneGenComponent::updateConfigurationDict
virtual void updateConfigurationDict()
Updates the configuration dictionary from component settings.
Definition CWToneGenComponent.cpp:522
LibCyberRadio::Driver::CWToneGenComponent::getPhaseRange
virtual BasicDoubleList getPhaseRange() const
Gets the phase range.
Definition CWToneGenComponent.cpp:317
LibCyberRadio::Driver::CWToneGenComponent::~CWToneGenComponent
virtual ~CWToneGenComponent()
Destroys a CWToneGenComponent object.
Definition CWToneGenComponent.cpp:99
LibCyberRadio::Driver::CWToneGenComponent::getAmplitude
virtual double getAmplitude() const
Gets the signal amplitude.
Definition CWToneGenComponent.cpp:405
LibCyberRadio::Driver::CWToneGenComponent::initConfigurationDict
virtual void initConfigurationDict()
Initializes the configuration dictionary, defining the allowed keys.
Definition CWToneGenComponent.cpp:505
LibCyberRadio::Driver::CWToneGenComponent::executeSweepCommand
virtual bool executeSweepCommand(int index, int txIndex, double &sweepStart, double &sweepStop, double &sweepStep, double &dwellTime)
Executes the CW sweep set command.
Definition CWToneGenComponent.cpp:637
LibCyberRadio::Driver::CWToneGenComponent::getSweepStartRes
virtual double getSweepStartRes() const
Gets the sweep start resolution.
Definition CWToneGenComponent.cpp:338
LibCyberRadio::Driver::CWToneGenComponent::getFrequencyRes
virtual double getFrequencyRes() const
Gets the frequency resolution.
Definition CWToneGenComponent.cpp:299
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::getConfigurationValueAsBool
virtual bool getConfigurationValueAsBool(const std::string &key) const
Gets a named configuration value as a Boolean.
Definition Configurable.cpp:109
LibCyberRadio::Driver::Configurable::setConfigurationValueToDbl
virtual bool setConfigurationValueToDbl(const std::string &key, const double value)
Sets a named configuration value to a double value.
Definition Configurable.cpp:211
LibCyberRadio::Driver::ConfigurationDict
A configuration dictionary.
Definition Configurable.h:52
LibCyberRadio::Driver::ConfigurationDict::hasKey
virtual bool hasKey(const std::string &key) const
Determines if the dictionary has the given key.
Definition Configurable.cpp:52
LibCyberRadio::Driver::RadioComponent::updateConfigurationDict
virtual void updateConfigurationDict()
Updates the configuration dictionary from component settings.
Definition RadioComponent.cpp:122
LibCyberRadio::Driver::RadioComponent::operator=
virtual RadioComponent & operator=(const RadioComponent &other)
Assignment operator for RadioComponent objects.
Definition RadioComponent.cpp:44
LibCyberRadio::Driver::RadioComponent::RadioComponent
RadioComponent(const std::string &name="<unknown>", int index=0, RadioHandler *parent=NULL, bool debug=false)
Constructs a RadioComponent object.
Definition RadioComponent.cpp:20
LibCyberRadio::Driver::RadioComponent::initConfigurationDict
virtual void initConfigurationDict()
Initializes the configuration dictionary, defining the allowed keys.
Definition RadioComponent.cpp:115
LibCyberRadio::Driver::RadioHandler
Generic radio handler class.
Definition RadioHandler.h:55
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
Defines functionality for LibCyberRadio applications.
Definition App.h:24
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