libcyberradio  22.01.24
WbddcComponent.cpp
1 /***************************************************************************
2  * \file WbddcComponent.cpp
3  * \brief Defines the WBDDC interface for the NDR551.
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/NDR551/WbddcComponent.h"
12 #include "LibCyberRadio/Driver/RadioHandler.h"
13 #include <boost/format.hpp>
14 #include <json/json.h>
15 #include <boost/lexical_cast.hpp>
16 #include <iostream>
17 
18 
19 namespace LibCyberRadio
20 {
21  namespace Driver
22  {
23 
24  namespace NDR551
25  {
26 
27  WbddcComponent::WbddcComponent(int index,
28  ::LibCyberRadio::Driver::RadioHandler* parent,
29  bool debug,
30  int dataPort,
31  int rateIndex,
32  int udpDestination,
33  int vitaEnable,
34  int streamId) :
35  m551Parent( parent ),
36  ::LibCyberRadio::Driver::WbddcComponent(
37  /* const std::string& name */ (boost::format("NDR551-WBDDC%02d") % \
38  index).str(),
39  /* int index */ index,
40  /* ::LibCyberRadio::Driver::RadioHandler* parent */ parent,
41  /* bool debug */ debug,
42  /* bool tunable */ true,
43  /* bool selectableSource */ true,
44  /* bool selectableDataPort */ true,
45  /* bool agc */ true,
46  /* double freqRangeMin */ 0.0,
47  /* double freqRangeMax */ 0.0,
48  /* double freqRes */ 1e6,
49  /* double freqUnits */ 1e6,
50  /* int source */ index,
51  /* int dataPort */ dataPort,
52  /* double frequency */ 0.0,
53  /* int rateIndex */ rateIndex,
54  /* int udpDestination */ udpDestination,
55  /* int vitaEnable */ vitaEnable,
56  /* unsigned int streamId */ streamId)
57  {
58  this->debug("[NDR551::WbddcComponent] index - %d\n", index);
59 
60  initConfigurationDict();
61  // Set rate set
62  _rateSet[40] = 128.0e6;
63  _rateSet[39] = 64.0e6;
64  _rateSet[38] = 32.0e6;
65  _rateSet[37] = 32.0e6;
66  _rateSet[36] = 16.0e6;
67  _rateSet[35] = 16.0e6;
68  _rateSet[34] = 16.0e6;
69  _rateSet[33] = 8.0e6;
70  _rateSet[32] = 8.0e6;
71  }
72 
73  WbddcComponent::~WbddcComponent()
74  {
75  }
76 
77  WbddcComponent::WbddcComponent(const WbddcComponent& other) :
78  ::LibCyberRadio::Driver::WbddcComponent(other)
79  {
80  }
81 
82  WbddcComponent& WbddcComponent::operator=(const WbddcComponent& other)
83  {
84  ::LibCyberRadio::Driver::WbddcComponent::operator=(other);
85  if ( this != &other )
86  {
87  }
88  return *this;
89  }
90 
91  void WbddcComponent::initConfigurationDict()
92  {
93  //this->debug("[WbddcComponent::initConfigurationDict] Called\n");
94  _config.clear();
95  // Call the base-class version
96  RadioComponent::initConfigurationDict();
97  // Define tuner-specific keys
98  _config["filter"] = 40;
99  _config["dest"] = 0;
100  _config["enable"] = false;
101  _config["vita"] = 0;
102  _config["type"] = "auto";
103  _config["decimation"] = _decimation;
104  _config["ovs"] = 1;
105  _config["mode"] = _mode;
106  _config["dgv"] = _dgv;
107  _config["dul"] = _dul;
108  _config["dll"] = _dll;
109  _config["dtl"] = _dtl;
110  _config["dal"] = _dal;
111  _config["ddl"] = _ddl;
112  _config["dao"] = _dao;
113  _config["ddo"] = _ddo;
114  _config["datc"] = _datc;
115  _config["ddtc"] = _ddtc;
116  _config["ddt"] = 90;
117  if ( _tunable )
118  {
119  _config["offset"] = 0.0f;
120  }
121  if ( _selectableSource )
122  {
123  _config["rfch"] = "0";
124  }
125  if ( _selectableDataPort )
126  {
127  _config["link"] = 0;
128  }
129  //this->debug("[WbddcComponent::initConfigurationDict] Returning\n");
130  }
131 
132  bool WbddcComponent::setConfiguration(ConfigurationDict& cfg)
133  {
134  bool ret = false;
135  this->debug("[NDR551WbddcComponent::setConfiguration] Called\n");
136  // Setup the JSON Command.
137  Json::Value command;
138  Json::Value params;
139  command["cmd"] = "wbddc";
140  command["msg"] = _parent->getMessageId();
141  command["params"] = Json::objectValue;
142  command["params"]["id"] = _index;
143 
144  for( ConfigurationDict::const_iterator it = cfg.begin();
145  it != cfg.end(); ++it)
146  {
147  if ( (it->first == "mode") ||
148  (it->first == "rfch") ||
149  (it->first == "type") )
150  {
151  command["params"][it->first.c_str()] = it->second.c_str();
152  }
153  else if ( (it->first == "enable") )
154  {
155  command["params"][it->first.c_str()] = it->second.asBool();
156  }
157  else
158  {
159  command["params"][it->first.c_str()] = it->second.asInt();
160  }
161  }
162  Json::FastWriter fastWriter;
163  std::string output = fastWriter.write(command);
164  std::cout << output << std::endl;
165  BasicStringList rsp = _parent->sendCommand(output);
166  Json::Reader reader;
167  Json::Value returnVal;
168  std::string t = rsp.at(0);
169  bool parsingSuccessful = reader.parse( t.c_str(), returnVal ); //parse process
170  ret = returnVal["success"].asBool();
171  return ret;
172  }
173 
174  void WbddcComponent::updateConfigurationDict()
175  {
176  this->debug("[NDR551WbddcComponent::updateConfigurationDict] Called\n");
177  RadioComponent::updateConfigurationDict();
178  if ( _config.hasKey("filter") )
179  setConfigurationValueToInt("filter", _rateIndex);
180  if ( _config.hasKey("dest") )
181  setConfigurationValueToInt("dest", _udpDestination);
182  if ( _config.hasKey("enable") )
183  setConfigurationValueToInt("enable", _vitaEnable);
184  if ( _config.hasKey("vita") )
185  setConfigurationValueToUInt("vita", _streamId);
186  if ( _tunable && _config.hasKey("offset") )
187  {
188  setConfigurationValueToDbl("offset", _frequency);
189  }
190  if ( _selectableSource && _config.hasKey("rfch") )
191  {
192  setConfigurationValueToInt("rfch", _source);
193  }
194  if ( _selectableDataPort && _config.hasKey("link") )
195  {
196  setConfigurationValueToInt("link", _dataPort);
197  }
198  if ( _config.hasKey("mode") )
199  {
200  setConfigurationValue("mode", _mode);
201  }
202  if ( _config.hasKey("decimation") )
203  {
204  setConfigurationValueToInt("decimation", _decimation);
205  }
206  if ( _config.hasKey("dgv" ) )
207  {
208  setConfigurationValueToInt("dgv", _dgv);
209  }
210  if ( _config.hasKey("dul" ) )
211  {
212  setConfigurationValueToInt("dul", _dul);
213  }
214  if ( _config.hasKey("dll" ) )
215  {
216  setConfigurationValueToInt("dll", _dll);
217  }
218  if ( _config.hasKey("dtl" ) )
219  {
220  setConfigurationValueToInt("dtl", _dtl);
221  }
222  if ( _config.hasKey("dal" ) )
223  {
224  setConfigurationValueToInt("dal", _dal);
225  }
226  if ( _config.hasKey("ddl" ) )
227  {
228  setConfigurationValueToInt("ddl", _ddl);
229  }
230  if ( _config.hasKey("dao" ) )
231  {
232  setConfigurationValueToInt("dao", _dao);
233  }
234  if ( _config.hasKey("ddo" ) )
235  {
236  setConfigurationValueToInt("ddo", _ddo);
237  }
238  if ( _config.hasKey("datc") )
239  {
240  setConfigurationValueToInt("datc", _datc);
241  }
242  if ( _config.hasKey("ddtc") )
243  {
244  setConfigurationValueToInt("ddtc", _ddtc);
245  }
246  if ( _config.hasKey("ddt" ) )
247  {
248  setConfigurationValueToInt("ddt", _ddt);
249  }
250  if ( _config.hasKey("type") )
251  {
252  setConfigurationValue("type", _type);
253  }
254  }
255 
256  void WbddcComponent::queryConfiguration()
257  {
258  this->debug("[WbddcComponent::queryConfiguration] Called\n");
259  Json::Value command;
260  Json::Value params;
261  command["cmd"] = "qwbddc";
262  command["msg"] = _parent->getMessageId();
263  command["params"] = Json::objectValue;
264  command["params"]["id"] = _index;
265  Json::FastWriter fastWriter;
266  std::string output = fastWriter.write(command);
267  BasicStringList rsp = _parent->sendCommand(output);
268  Json::Reader reader;
269  Json::Value returnVal;
270  std::string t = rsp.at(0);
271  bool parsingSuccessful = reader.parse( t.c_str(), returnVal ); //parse process
272  if( parsingSuccessful && returnVal.isMember("result") ) {
273  _enabled = boost::lexical_cast<bool>(returnVal["result"]["enable"].asBool());
274  _frequency = boost::lexical_cast<double>(returnVal["result"]["offset"].asDouble());
275  _source = boost::lexical_cast<int>(returnVal["result"]["rfch"].asString());
276  _dataPort = boost::lexical_cast<int>(returnVal["result"]["link"].asInt());
277  _udpDestination = boost::lexical_cast<int>(returnVal["result"]["dest"].asInt());
278  _rateIndex = boost::lexical_cast<int>(returnVal["result"]["filter"].asInt());
279  _streamId = boost::lexical_cast<int>(returnVal["result"]["vita"].asUInt());
280  _ovs = boost::lexical_cast<int>(returnVal["result"]["ovs"].asInt());
281  _decimation = boost::lexical_cast<int>(returnVal["result"]["decimation"].asInt());
282  _type = boost::lexical_cast<std::string>(returnVal["result"]["type"].asString());
283  _mode = boost::lexical_cast<std::string>(returnVal["result"]["mode"].asString());
284  _dgv = boost::lexical_cast<int>(returnVal["result"]["dgv"].asInt());
285  _dul = boost::lexical_cast<int>(returnVal["result"]["dul"].asInt());
286  _dll = boost::lexical_cast<int>(returnVal["result"]["dll"].asInt());
287  _dtl = boost::lexical_cast<int>(returnVal["result"]["dtl"].asInt());
288  _dal = boost::lexical_cast<int>(returnVal["result"]["dal"].asInt());
289  _ddl = boost::lexical_cast<int>(returnVal["result"]["ddl"].asInt());
290  _dao = boost::lexical_cast<int>(returnVal["result"]["dao"].asInt());
291  _ddo = boost::lexical_cast<int>(returnVal["result"]["ddo"].asInt());
292  _datc = boost::lexical_cast<int>(returnVal["result"]["datc"].asInt());
293  _ddtc = boost::lexical_cast<int>(returnVal["result"]["ddtc"].asInt());
294  _dat = boost::lexical_cast<int>(returnVal["result"]["dat"].asInt());
295  _ddt = boost::lexical_cast<int>(returnVal["result"]["ddt"].asInt());
296  updateConfigurationDict();
297  }
298  this->debug("[WbddcComponent::queryConfiguration] Returning\n");
299  }
300 
305  bool WbddcComponent::executeWbddcQuery(int index, int& rateIndex,
306  int& udpDestination, bool& enabled, int& vitaEnable,
307  unsigned int& streamId)
308  {
309  bool ret = false;
310  if ( (_parent != NULL) && (_parent->isConnected()) )
311  {
312  Json::Value root(Json::objectValue);
313  root["msg"] = m551Parent->getMessageId();
314  Json::Value params(Json::objectValue);
315  params["id"] = index;
316  root["params"] = params;
317  Json::FastWriter fastWriter;
318  std::string output = fastWriter.write(root);
319  LibCyberRadio::BasicStringList recv = _parent->sendCommand(output,1.0);
320  Json::Reader reader;
321  Json::Value returnVal;
322  std::string t = recv.at(0);
323  bool parsingSuccessful = reader.parse( t.c_str(), returnVal ); //parse process
324  Json::Value result = returnVal["result"];
325  rateIndex = boost::lexical_cast<int>(result["filter"].asInt());
326  udpDestination = boost::lexical_cast<int>(result["dest"].asInt());
327  enabled = boost::lexical_cast<int>(result["enable"].asBool());
328  vitaEnable = boost::lexical_cast<int>(result["enable"].asBool());
329  streamId = boost::lexical_cast<unsigned int>(result["vita"].asUInt());
330  }
331  return ret;
332  }
333 
334  bool WbddcComponent::executeDataPortCommand(int index, int& dataPort)
335  {
336  bool ret = false;
337  if ( (_parent != NULL) && (_parent->isConnected()) )
338  {
339  Json::Value root(Json::objectValue);
340  root["msg"] = m551Parent->getMessageId();
341  root["cmd"] = "wbddc";
342  Json::Value params(Json::objectValue);
343  params["id"] = index;
344  params["link"] = dataPort;
345  root["params"] = params;
346  Json::FastWriter fastWriter;
347  std::string output = fastWriter.write(root);
348  LibCyberRadio::BasicStringList recv = _parent->sendCommand(output,1.0);
349  Json::Reader reader;
350  Json::Value returnVal;
351  std::string t = recv.at(0);
352  bool parsingSuccessful = reader.parse( t.c_str(), returnVal ); //parse process
353  ret = returnVal["success"].asBool();
354  }
355  return ret;
356  }
357 
358  // Default implementation returns false, since it is based on
359  // the NDR308, which does not support selectable-source WBDDCs.
360  bool WbddcComponent::executeSourceCommand(int index, int& source)
361  {
362  bool ret = false;
363  if ( (_parent != NULL) && (_parent->isConnected()) )
364  {
365  Json::Value root(Json::objectValue);
366  root["msg"] = m551Parent->getMessageId();
367  root["cmd"] = "wbddc";
368  Json::Value params(Json::objectValue);
369  params["id"] = index;
370 
371  params["rfch"] = std::to_string(source);
372  root["params"] = params;
373  Json::FastWriter fastWriter;
374  std::string output = fastWriter.write(root);
375  LibCyberRadio::BasicStringList recv = _parent->sendCommand(output,1.0);
376  Json::Reader reader;
377  Json::Value returnVal;
378  std::string t = recv.at(0);
379  bool parsingSuccessful = reader.parse( t.c_str(), returnVal ); //parse process
380  ret = returnVal["success"].asBool();
381  }
382  return ret;
383  }
384  // Default implementation returns false, since it is based on
385  // the NDR308, which does not support tunable WBDDCs.
386  bool WbddcComponent::executeFreqCommand(int index, double& freq)
387  {
388  bool ret = false;
389  if ( (_parent != NULL) && (_parent->isConnected()) )
390  {
391  Json::Value root(Json::objectValue);
392  root["msg"] = m551Parent->getMessageId();
393  root["cmd"] = "wbddc";
394  Json::Value params(Json::objectValue);
395  params["id"] = index;
396  params["offset"] = freq;
397  root["params"] = params;
398  Json::FastWriter fastWriter;
399  std::string output = fastWriter.write(root);
400  LibCyberRadio::BasicStringList recv = _parent->sendCommand(output,1.0);
401  Json::Reader reader;
402  Json::Value returnVal;
403  std::string t = recv.at(0);
404  bool parsingSuccessful = reader.parse( t.c_str(), returnVal ); //parse process
405  ret = returnVal["success"].asBool();
406  }
407  return ret;
408  }
409 
410  // Default implementation uses the NDR308 syntax.
411  // WBDDC <index>, <rate index>, <udp dest>, <enable>, <vita enable>, <stream id>
412  bool WbddcComponent::executeWbddcCommand(int index, int& rateIndex,
413  int& udpDestination, bool& enabled, int& vitaEnable,
414  unsigned int& streamId)
415  {
416  bool ret = false;
417  if ( (_parent != NULL) && (_parent->isConnected()) )
418  {
419  Json::Value root(Json::objectValue);
420  root["msg"] = m551Parent->getMessageId();
421  root["cmd"] = "wbddc";
422  Json::Value params(Json::objectValue);
423  params["id"] = index;
424  params["filter"] = rateIndex;
425  params["dest"] = udpDestination;
426  params["enable"] = boost::lexical_cast<bool>(enabled);
427  params["vita"] = streamId;
428  root["params"] = params;
429  Json::FastWriter fastWriter;
430  std::string output = fastWriter.write(root);
431  LibCyberRadio::BasicStringList recv = _parent->sendCommand(output,1.0);
432  Json::Reader reader;
433  Json::Value returnVal;
434  std::string t = recv.at(0);
435  bool parsingSuccessful = reader.parse( t.c_str(), returnVal ); //parse process
436  ret = returnVal["success"].asBool();
437  }
438  return ret;
439  }
440 
441  bool WbddcComponent::setRateIndex(int index)
442  {
443  bool ret = false;
444  if ( _config.hasKey("filter") )
445  {
446  int adjRateIndex = index;
447  int adjUdpDest = _udpDestination;
448  int adjVita = _vitaEnable;
449  unsigned int adjStream = _streamId;
450  bool adjEnabled = _enabled;
451  ret = executeWbddcCommand(_index, adjRateIndex, adjUdpDest, adjEnabled, adjVita, adjStream);
452  if ( ret )
453  {
454  _rateIndex = adjRateIndex;
455  updateConfigurationDict();
456  }
457  }
458  return ret;
459  }
460 
461  bool WbddcComponent::setFrequency(double freq)
462  {
463  bool ret = false;
464  if ( _tunable && _config.hasKey("offset") )
465  {
466  double adjFreq = freq;
467  ret = executeFreqCommand(_index, adjFreq);
468  if ( ret )
469  {
470  _frequency = adjFreq;
471  updateConfigurationDict();
472  }
473  }
474  return ret;
475  }
476 
477  bool WbddcComponent::setSource(int source)
478  {
479  bool ret = false;
480  if ( _config.hasKey("rfch") )
481  {
482  int adjSource = source;
483  ret = executeSourceCommand(_index, adjSource);
484  if ( ret )
485  {
486  _source = adjSource;
487  updateConfigurationDict();
488  }
489  }
490  return ret;
491  }
492 
493  bool WbddcComponent::setUdpDestination(int dest)
494  {
495  bool ret = false;
496  if ( _config.hasKey("dest") )
497  {
498  int adjRateIndex = _rateIndex;
499  int adjUdpDest = dest;
500  int adjVita = _vitaEnable;
501  unsigned int adjStream = _streamId;
502  bool adjEnabled = _enabled;
503  ret = executeWbddcCommand(_index, adjRateIndex, adjUdpDest, adjEnabled, adjVita, adjStream);
504  if ( ret )
505  {
506  _udpDestination = adjUdpDest;
507  updateConfigurationDict();
508  }
509  }
510  return ret;
511  }
512 
513  } /* namespace NDR551 */
514 
515  } // namespace Driver
516 
517 } // namespace LibCyberRadio
518 
LibCyberRadio::Driver::RadioComponent::updateConfigurationDict
virtual void updateConfigurationDict()
Updates the configuration dictionary from component settings.
Definition: RadioComponent.cpp:122
LibCyberRadio::Driver::NDR551::WbddcComponent::updateConfigurationDict
virtual void updateConfigurationDict() override
Updates the configuration dictionary from component settings.
Definition: WbddcComponent.cpp:174
LibCyberRadio::Driver::NDR551::WbddcComponent::operator=
virtual WbddcComponent & operator=(const WbddcComponent &other)
Assignment operator for WbddcComponent objects.
Definition: WbddcComponent.cpp:82
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::NDR551::WbddcComponent::setUdpDestination
bool setUdpDestination(int dest) override
Sets the WBDDC&#39;s UDP destination.
Definition: WbddcComponent.cpp:493
LibCyberRadio::Driver::NDR551::WbddcComponent::executeFreqCommand
bool executeFreqCommand(int index, double &freq) override
Executes the WBDDC frequency set command.
Definition: WbddcComponent.cpp:386
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::NDR551::WbddcComponent::executeSourceCommand
bool executeSourceCommand(int index, int &source) override
Executes the WBDDC source set command.
Definition: WbddcComponent.cpp:360
LibCyberRadio::Driver::NDR551::WbddcComponent::initConfigurationDict
void initConfigurationDict() override
Setup Config Dict.
Definition: WbddcComponent.cpp:91
LibCyberRadio::Driver::NDR551::WbddcComponent::WbddcComponent
WbddcComponent(int index=1, ::LibCyberRadio::Driver::RadioHandler *parent=NULL, bool debug=false, int dataPort=1, int rateIndex=0, int udpDestination=0, int vitaEnable=0, int streamId=0)
Constructs a WbddcComponent object.
Definition: WbddcComponent.cpp:27
LibCyberRadio::Driver::NDR551::WbddcComponent::setConfiguration
virtual bool setConfiguration(ConfigurationDict &cfg) override
Sets the configuration dictionary for this component.
Definition: WbddcComponent.cpp:132
LibCyberRadio::Driver::NDR551::WbddcComponent::setSource
bool setSource(int source) override
Sets the WBDDC&#39;s source (which tuner is supplying the signal).
Definition: WbddcComponent.cpp:477
LibCyberRadio::Driver::RadioHandler::isConnected
virtual bool isConnected() const
Gets whether or not the handler is connected.
Definition: RadioHandler.cpp:245
LibCyberRadio::Driver::Configurable::setConfigurationValueToUInt
virtual bool setConfigurationValueToUInt(const std::string &key, const unsigned int value)
Sets a named configuration value to an unsigned integer value.
Definition: Configurable.cpp:205
LibCyberRadio::Driver::NDR551::WbddcComponent::executeWbddcCommand
bool executeWbddcCommand(int index, int &rateIndex, int &udpDestination, bool &enabled, int &vitaEnable, unsigned int &streamId) override
Executes the WBDDC configuration set command.
Definition: WbddcComponent.cpp:412
LibCyberRadio::Driver::RadioHandler
Generic radio handler class.
Definition: RadioHandler.h:54
LibCyberRadio::Debuggable::debug
virtual int debug(const char *format,...)
Outputs debug information.
Definition: Debuggable.cpp:95
LibCyberRadio::BasicStringList
BASIC_LIST_CONTAINER< std::string > BasicStringList
Type representing a list of strings.
Definition: BasicList.h:25
LibCyberRadio::Driver::NDR551::WbddcComponent
WBDDC component class for the NDR551.
Definition: WbddcComponent.h:50
LibCyberRadio::Driver::RadioComponent::initConfigurationDict
virtual void initConfigurationDict()
Initializes the configuration dictionary, defining the allowed keys.
Definition: RadioComponent.cpp:115
LibCyberRadio::Driver::NDR551::WbddcComponent::setRateIndex
bool setRateIndex(int index) override
Sets the WBDDC&#39;s rate index.
Definition: WbddcComponent.cpp:441
LibCyberRadio
Defines functionality for LibCyberRadio applications.
Definition: App.h:23
LibCyberRadio::Driver::ConfigurationDict
A configuration dictionary.
Definition: Configurable.h:51
LibCyberRadio::Driver::NDR551::WbddcComponent::~WbddcComponent
virtual ~WbddcComponent()
Destroys a WbddcComponent object.
Definition: WbddcComponent.cpp:73
LibCyberRadio::Driver::NDR551::WbddcComponent::queryConfiguration
void queryConfiguration() override
Tells the component to query its hardware configuration in order to create its configuration dictiona...
Definition: WbddcComponent.cpp:256
LibCyberRadio::Driver::NDR551::WbddcComponent::executeDataPortCommand
bool executeDataPortCommand(int index, int &dataPort) override
Executes the WBDDC data port set command.
Definition: WbddcComponent.cpp:334
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::NDR551::WbddcComponent::executeWbddcQuery
bool executeWbddcQuery(int index, int &rateIndex, int &udpDestination, bool &enabled, int &vitaEnable, unsigned int &streamId)
Execute a JSON wbddc Query.
Definition: WbddcComponent.cpp:305
LibCyberRadio::Driver::Configurable::setConfigurationValue
virtual bool setConfigurationValue(const std::string &key, const std::string &value)
Sets a named configuration value to a string.
Definition: Configurable.cpp:177
LibCyberRadio::Driver::NDR551::WbddcComponent::setFrequency
bool setFrequency(double freq) override
Sets the WBDDC tuned frequency.
Definition: WbddcComponent.cpp:461
LibCyberRadio::Driver::RadioHandler::getMessageId
virtual uint32_t getMessageId(void)
Get a json Message ID.
Definition: RadioHandler.cpp:3417
LibCyberRadio::Driver::Configurable::setConfigurationValueToInt
virtual bool setConfigurationValueToInt(const std::string &key, const int value)
Sets a named configuration value to an integer value.
Definition: Configurable.cpp:199