fe_tuner_port_impl.h
Go to the documentation of this file.
1 /*
2  * This file is protected by Copyright. Please refer to the COPYRIGHT file
3  * distributed with this source distribution.
4  *
5  * This file is part of REDHAWK frontendInterfaces.
6  *
7  * REDHAWK frontendInterfaces is free software: you can redistribute it and/or modify it
8  * under the terms of the GNU Lesser General Public License as published by the
9  * Free Software Foundation, either version 3 of the License, or (at your
10  * option) any later version.
11  *
12  * REDHAWK frontendInterfaces is distributed in the hope that it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
15  * for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public License
18  * along with this program. If not, see http://www.gnu.org/licenses/.
19  */
20 #ifndef FE_TUNER_PORT_H
21 #define FE_TUNER_PORT_H
22 
23 #include "fe_port_impl.h"
24 
25 #include <redhawk/FRONTEND/TunerControl.h>
26 
27 
28 namespace frontend {
29 
31  public:
32  virtual std::string getTunerType(const std::string& id) {
33  throw FRONTEND::NotSupportedException("getTunerType not supported");
34  }
35  virtual bool getTunerDeviceControl(const std::string& id) {
36  throw FRONTEND::NotSupportedException("getTunerDeviceControl not supported");
37  }
38  virtual std::string getTunerGroupId(const std::string& id) {
39  throw FRONTEND::NotSupportedException("getTunerGroupId not supported");
40  }
41  virtual std::string getTunerRfFlowId(const std::string& id) {
42  throw FRONTEND::NotSupportedException("getTunerRfFlowId not supported");
43  }
44  virtual CF::Properties* getTunerStatus(const std::string& id) = 0;
45  };
46 
47  class analog_tuner_delegation : public virtual tuner_delegation {
48  public:
49  virtual void setTunerCenterFrequency(const std::string& id, double freq) {
50  throw FRONTEND::NotSupportedException("setTunerCenterFrequency not supported");
51  }
52  virtual double getTunerCenterFrequency(const std::string& id) {
53  throw FRONTEND::NotSupportedException("getTunerCenterFrequency not supported");
54  }
55  virtual void setTunerBandwidth(const std::string& id, double bw) {
56  throw FRONTEND::NotSupportedException("setTunerBandwidth not supported");
57  }
58  virtual double getTunerBandwidth(const std::string& id) {
59  throw FRONTEND::NotSupportedException("getTunerBandwidth not supported");
60  }
61  virtual void setTunerAgcEnable(const std::string& id, bool enable) {
62  throw FRONTEND::NotSupportedException("setTunerAgcEnable not supported");
63  }
64  virtual bool getTunerAgcEnable(const std::string& id) {
65  throw FRONTEND::NotSupportedException("getTunerAgcEnable not supported");
66  }
67  virtual void setTunerGain(const std::string& id, float gain) {
68  throw FRONTEND::NotSupportedException("setTunerGain not supported");
69  }
70  virtual float getTunerGain(const std::string& id) {
71  throw FRONTEND::NotSupportedException("getTunerGain not supported");
72  }
73  virtual void setTunerReferenceSource(const std::string& id, long source) {
74  throw FRONTEND::NotSupportedException("setTunerReferenceSource not supported");
75  }
76  virtual long getTunerReferenceSource(const std::string& id) {
77  throw FRONTEND::NotSupportedException("getTunerReferenceSource not supported");
78  }
79  virtual void setTunerEnable(const std::string& id, bool enable) {
80  throw FRONTEND::NotSupportedException("setTunerEnable not supported");
81  }
82  virtual bool getTunerEnable(const std::string& id) {
83  throw FRONTEND::NotSupportedException("getTunerEnable not supported");
84  }
85  };
86 
88  public:
89  virtual void setTunerOutputSampleRate(const std::string& id, double sr) {
90  throw FRONTEND::NotSupportedException("setTunerOutputSampleRate not supported");
91  }
92  virtual double getTunerOutputSampleRate(const std::string& id) {
93  throw FRONTEND::NotSupportedException("getTunerOutputSampleRate not supported");
94  }
95  };
96 
97  class InFrontendTunerPort : public virtual POA_FRONTEND::FrontendTuner, public Port_Provides_base_impl
98  {
99  public:
100  InFrontendTunerPort(std::string port_name, tuner_delegation *_parent):
101  Port_Provides_base_impl(port_name)
102  {
103  parent = _parent;
104  };
106  char* getTunerType(const char* id) {
107  boost::mutex::scoped_lock lock(portAccess);
108  std::string _id(id);
109  return (CORBA::string_dup(this->parent->getTunerType(_id).c_str()));
110  };
111  CORBA::Boolean getTunerDeviceControl(const char* id) {
112  boost::mutex::scoped_lock lock(portAccess);
113  std::string _id(id);
114  return (this->parent->getTunerDeviceControl(_id));
115  };
116  char* getTunerGroupId(const char* id) {
117  boost::mutex::scoped_lock lock(portAccess);
118  std::string _id(id);
119  return (CORBA::string_dup(this->parent->getTunerGroupId(_id).c_str()));
120  };
121  char* getTunerRfFlowId(const char* id) {
122  boost::mutex::scoped_lock lock(portAccess);
123  std::string _id(id);
124  return (CORBA::string_dup(this->parent->getTunerRfFlowId(_id).c_str()));
125  };
126  CF::Properties* getTunerStatus(const char* id) {
127  boost::mutex::scoped_lock lock(portAccess);
128  std::string _id(id);
129  return (this->parent->getTunerStatus(_id));
130  };
131  std::string getRepid() const {
132  return "IDL:FRONTEND/FrontendTuner:1.0";
133  };
134  protected:
135  boost::mutex portAccess;
136  private:
137  tuner_delegation *parent;
138  };
139 
140  class InAnalogTunerPort : public virtual POA_FRONTEND::AnalogTuner, public InFrontendTunerPort
141  {
142  public:
144  InAnalogTunerPort(std::string port_name, analog_tuner_delegation *_parent):super(port_name, _parent)
145  {
146  parent = _parent;
147  };
149  void setTunerCenterFrequency(const char* id, CORBA::Double freq) {
150  boost::mutex::scoped_lock lock(this->portAccess);
151  std::string _id(id);
152  this->parent->setTunerCenterFrequency(_id, freq);
153  };
155  boost::mutex::scoped_lock lock(this->portAccess);
156  std::string _id(id);
157  return (this->parent->getTunerCenterFrequency(_id));
158  };
159  void setTunerBandwidth(const char* id, CORBA::Double bw) {
160  boost::mutex::scoped_lock lock(this->portAccess);
161  std::string _id(id);
162  this->parent->setTunerBandwidth(_id, bw);
163  };
165  boost::mutex::scoped_lock lock(this->portAccess);
166  std::string _id(id);
167  return (this->parent->getTunerBandwidth(_id));
168  };
169  void setTunerAgcEnable(const char* id, CORBA::Boolean enable) {
170  boost::mutex::scoped_lock lock(this->portAccess);
171  std::string _id(id);
172  this->parent->setTunerAgcEnable(_id, enable);
173  };
174  CORBA::Boolean getTunerAgcEnable(const char* id) {
175  boost::mutex::scoped_lock lock(this->portAccess);
176  std::string _id(id);
177  return (this->parent->getTunerAgcEnable(_id));
178  };
179  void setTunerGain(const char* id, CORBA::Float gain) {
180  boost::mutex::scoped_lock lock(this->portAccess);
181  std::string _id(id);
182  this->parent->setTunerGain(_id, gain);
183  };
184  CORBA::Float getTunerGain(const char* id) {
185  boost::mutex::scoped_lock lock(this->portAccess);
186  std::string _id(id);
187  return (this->parent->getTunerGain(_id));
188  };
189  void setTunerReferenceSource(const char* id, CORBA::Long source) {
190  boost::mutex::scoped_lock lock(this->portAccess);
191  std::string _id(id);
192  this->parent->setTunerReferenceSource(_id, source);
193  };
194  CORBA::Long getTunerReferenceSource(const char* id) {
195  boost::mutex::scoped_lock lock(this->portAccess);
196  std::string _id(id);
197  return (this->parent->getTunerReferenceSource(_id));
198  };
199  void setTunerEnable(const char* id, CORBA::Boolean enable) {
200  boost::mutex::scoped_lock lock(this->portAccess);
201  std::string _id(id);
202  this->parent->setTunerEnable(_id, enable);
203  };
204  CORBA::Boolean getTunerEnable(const char* id) {
205  boost::mutex::scoped_lock lock(this->portAccess);
206  std::string _id(id);
207  return (this->parent->getTunerEnable(_id));
208  };
209  std::string getRepid() const {
210  return "IDL:FRONTEND/AnalogTuner:1.0";
211  };
212  private:
213  analog_tuner_delegation *parent;
214  };
215 
216  class InDigitalTunerPort : public virtual POA_FRONTEND::DigitalTuner, public InAnalogTunerPort
217  {
218  public:
220  InDigitalTunerPort(std::string port_name, digital_tuner_delegation *_parent):super(port_name, _parent)
221  {
222  parent = _parent;
223  };
225  void setTunerOutputSampleRate(const char* id, CORBA::Double sr) {
226  boost::mutex::scoped_lock lock(this->portAccess);
227  std::string _id(id);
228  this->parent->setTunerOutputSampleRate(_id, sr);
229  };
231  boost::mutex::scoped_lock lock(this->portAccess);
232  std::string _id(id);
233  return (this->parent->getTunerOutputSampleRate(_id));
234  };
235  std::string getRepid() const {
236  return "IDL:FRONTEND/DigitalTuner:1.0";
237  };
238  private:
239  digital_tuner_delegation *parent;
240  };
241 
242 
243  template<typename PortType_var, typename PortType>
244  class OutFrontendTunerPortT : public OutFrontendPort<PortType_var, PortType>
245  {
246  public:
247  OutFrontendTunerPortT(std::string port_name) : OutFrontendPort<PortType_var, PortType>(port_name)
248  {};
250 
251  std::string getTunerType(std::string &id) {
252  CORBA::String_var retval;
253  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
254  boost::mutex::scoped_lock lock(this->updatingPortsLock); // don't want to process while command information is coming in
255  if (this->active) {
256  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
257  try {
258  retval = ((*i).first)->getTunerType(id.c_str());
259  } catch(...) {
260  }
261  }
262  }
263  std::string str_retval = ossie::corba::returnString(retval);
264  return str_retval;
265  };
266  bool getTunerDeviceControl(std::string &id) {
267  CORBA::Boolean retval;
268  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
269  boost::mutex::scoped_lock lock(this->updatingPortsLock); // don't want to process while command information is coming in
270  if (this->active) {
271  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
272  try {
273  retval = ((*i).first)->getTunerDeviceControl(id.c_str());
274  } catch(...) {
275  }
276  }
277  }
278  return retval;
279  };
280  std::string getTunerGroupId(std::string &id) {
281  CORBA::String_var retval;
282  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
283  boost::mutex::scoped_lock lock(this->updatingPortsLock); // don't want to process while command information is coming in
284  if (this->active) {
285  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
286  try {
287  retval = ((*i).first)->getTunerGroupId(id.c_str());
288  } catch(...) {
289  }
290  }
291  }
292  std::string str_retval = ossie::corba::returnString(retval);
293  return str_retval;
294  };
295  std::string getTunerRfFlowId(std::string &id) {
296  CORBA::String_var retval;
297  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
298  boost::mutex::scoped_lock lock(this->updatingPortsLock); // don't want to process while command information is coming in
299  if (this->active) {
300  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
301  try {
302  retval = ((*i).first)->getTunerRfFlowId(id.c_str());
303  } catch(...) {
304  }
305  }
306  }
307  std::string str_retval = ossie::corba::returnString(retval);
308  return str_retval;
309  };
310  CF::Properties* getTunerStatus(std::string &id) {
311  CF::Properties* retval;
312  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
313  boost::mutex::scoped_lock lock(this->updatingPortsLock); // don't want to process while command information is coming in
314  if (this->active) {
315  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
316  try {
317  retval = ((*i).first)->getTunerStatus(id.c_str());
318  } catch(...) {
319  }
320  }
321  }
322  return retval;
323  };
324  };
325 
326  template<typename PortType_var, typename PortType>
327  class OutAnalogTunerPortT : public OutFrontendTunerPortT<PortType_var, PortType>
328  {
329  public:
330  OutAnalogTunerPortT(std::string port_name) : OutFrontendTunerPortT<PortType_var, PortType>(port_name)
331  {};
333 
334  void setTunerCenterFrequency(std::string &id, double freq) {
335  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
336  boost::mutex::scoped_lock lock(this->updatingPortsLock);
337  if (this->active) {
338  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
339  try {
340  ((*i).first)->setTunerCenterFrequency(id.c_str(), freq);
341  } catch(...) {
342  }
343  }
344  }
345  return;
346  };
347  double getTunerCenterFrequency(std::string &id) {
348  CORBA::Double retval;
349  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
350  boost::mutex::scoped_lock lock(this->updatingPortsLock);
351  if (this->active) {
352  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
353  try {
354  retval = ((*i).first)->getTunerCenterFrequency(id.c_str());
355  } catch(...) {
356  }
357  }
358  }
359  return retval;
360  };
361  void setTunerBandwidth(std::string &id, double bw) {
362  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
363  boost::mutex::scoped_lock lock(this->updatingPortsLock);
364  if (this->active) {
365  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
366  try {
367  ((*i).first)->setTunerBandwidth(id.c_str(), bw);
368  } catch(...) {
369  }
370  }
371  }
372  return;
373  };
374  double getTunerBandwidth(std::string &id) {
375  CORBA::Double retval;
376  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
377  boost::mutex::scoped_lock lock(this->updatingPortsLock);
378  if (this->active) {
379  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
380  try {
381  retval = ((*i).first)->getTunerBandwidth(id.c_str());
382  } catch(...) {
383  }
384  }
385  }
386  return retval;
387  };
388  void setTunerAgcEnable(std::string &id, bool enable) {
389  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
390  boost::mutex::scoped_lock lock(this->updatingPortsLock);
391  if (this->active) {
392  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
393  try {
394  ((*i).first)->setTunerAgcEnable(id.c_str(), enable);
395  } catch(...) {
396  }
397  }
398  }
399  return;
400  };
401  bool getTunerAgcEnable(std::string &id) {
402  CORBA::Boolean retval;
403  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
404  boost::mutex::scoped_lock lock(this->updatingPortsLock);
405  if (this->active) {
406  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
407  try {
408  retval = ((*i).first)->getTunerAgcEnable(id.c_str());
409  } catch(...) {
410  }
411  }
412  }
413  return retval;
414  };
415  void setTunerGain(std::string &id, float gain) {
416  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
417  boost::mutex::scoped_lock lock(this->updatingPortsLock);
418  if (this->active) {
419  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
420  try {
421  ((*i).first)->setTunerGain(id.c_str(), gain);
422  } catch(...) {
423  }
424  }
425  }
426  return;
427  };
428  float getTunerGain(std::string &id) {
429  CORBA::Float retval;
430  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
431  boost::mutex::scoped_lock lock(this->updatingPortsLock);
432  if (this->active) {
433  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
434  try {
435  retval = ((*i).first)->getTunerGain(id.c_str());
436  } catch(...) {
437  }
438  }
439  }
440  return retval;
441  };
442  void setTunerReferenceSource(std::string &id, int source) {
443  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
444  boost::mutex::scoped_lock lock(this->updatingPortsLock);
445  if (this->active) {
446  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
447  try {
448  ((*i).first)->setTunerReferenceSource(id.c_str(), source);
449  } catch(...) {
450  }
451  }
452  }
453  return;
454  };
455  int getTunerReferenceSource(std::string &id) {
456  CORBA::Long retval;
457  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
458  boost::mutex::scoped_lock lock(this->updatingPortsLock);
459  if (this->active) {
460  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
461  try {
462  retval = ((*i).first)->getTunerReferenceSource(id.c_str());
463  } catch(...) {
464  }
465  }
466  }
467  return retval;
468  };
469  void setTunerEnable(std::string &id, bool enable) {
470  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
471  boost::mutex::scoped_lock lock(this->updatingPortsLock);
472  if (this->active) {
473  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
474  try {
475  ((*i).first)->setTunerEnable(id.c_str(), enable);
476  } catch(...) {
477  }
478  }
479  }
480  return;
481  };
482  bool getTunerEnable(std::string &id) {
483  CORBA::Boolean retval;
484  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
485  boost::mutex::scoped_lock lock(this->updatingPortsLock);
486  if (this->active) {
487  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
488  try {
489  retval = ((*i).first)->getTunerEnable(id.c_str());
490  } catch(...) {
491  }
492  }
493  }
494  return retval;
495  };
496  };
497 
498  template<typename PortType_var, typename PortType>
499  class OutDigitalTunerPortT : public OutAnalogTunerPortT<PortType_var, PortType>
500  {
501  public:
502  OutDigitalTunerPortT(std::string port_name) : OutAnalogTunerPortT<PortType_var, PortType>(port_name)
503  {};
505 
506  void setTunerOutputSampleRate(std::string &id, double sr) {
507  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
508  boost::mutex::scoped_lock lock(this->updatingPortsLock);
509  if (this->active) {
510  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
511  try {
512  ((*i).first)->setTunerOutputSampleRate(id.c_str(), sr);
513  } catch(...) {
514  }
515  }
516  }
517  return;
518  };
519  double getTunerOutputSampleRate(std::string &id) {
520  CORBA::Double retval;
521  typename std::vector < std::pair < PortType_var, std::string > >::iterator i;
522  boost::mutex::scoped_lock lock(this->updatingPortsLock);
523  if (this->active) {
524  for (i = this->outConnections.begin(); i != this->outConnections.end(); ++i) {
525  try {
526  retval = ((*i).first)->getTunerOutputSampleRate(id.c_str());
527  } catch(...) {
528  }
529  }
530  }
531  return retval;
532  };
533  };
534 
535  // ----------------------------------------------------------------------------------------
536  // OutFrontendTunerPort declaration
537  // ----------------------------------------------------------------------------------------
538  class OutFrontendTunerPort : public OutFrontendTunerPortT<FRONTEND::FrontendTuner_var,FRONTEND::FrontendTuner> {
539  public:
540  OutFrontendTunerPort(std::string port_name) : OutFrontendTunerPortT<FRONTEND::FrontendTuner_var,FRONTEND::FrontendTuner>(port_name)
541  {};
542  };
543 
544  // ----------------------------------------------------------------------------------------
545  // OutAnalogTunerPort declaration
546  // ----------------------------------------------------------------------------------------
547  class OutAnalogTunerPort : public OutAnalogTunerPortT<FRONTEND::AnalogTuner_var,FRONTEND::AnalogTuner> {
548  public:
549  OutAnalogTunerPort(std::string port_name) : OutAnalogTunerPortT<FRONTEND::AnalogTuner_var,FRONTEND::AnalogTuner>(port_name)
550  {};
551  };
552 
553  // ----------------------------------------------------------------------------------------
554  // OutDigitalTunerPort declaration
555  // ----------------------------------------------------------------------------------------
556  class OutDigitalTunerPort : public OutDigitalTunerPortT<FRONTEND::DigitalTuner_var,FRONTEND::DigitalTuner> {
557  public:
558  OutDigitalTunerPort(std::string port_name) : OutDigitalTunerPortT<FRONTEND::DigitalTuner_var,FRONTEND::DigitalTuner>(port_name)
559  {};
560  };
561 
562 } // end of frontend namespace
563 
564 
565 #endif
InDigitalTunerPort(std::string port_name, digital_tuner_delegation *_parent)
Definition: fe_tuner_port_impl.h:220
virtual void setTunerOutputSampleRate(const std::string &id, double sr)
Definition: fe_tuner_port_impl.h:89
virtual CF::Properties * getTunerStatus(const std::string &id)=0
float getTunerGain(std::string &id)
Definition: fe_tuner_port_impl.h:428
char * getTunerRfFlowId(const char *id)
Definition: fe_tuner_port_impl.h:121
virtual std::string getTunerRfFlowId(const std::string &id)
Definition: fe_tuner_port_impl.h:41
Definition: fe_tuner_port_impl.h:499
void setTunerReferenceSource(const char *id, CORBA::Long source)
Definition: fe_tuner_port_impl.h:189
~InDigitalTunerPort()
Definition: fe_tuner_port_impl.h:224
~OutAnalogTunerPortT()
Definition: fe_tuner_port_impl.h:332
Definition: fe_tuner_port_impl.h:87
boost::mutex updatingPortsLock
Definition: Port_impl.h:360
~InFrontendTunerPort()
Definition: fe_tuner_port_impl.h:105
Definition: fe_tuner_port_impl.h:30
Definition: fe_tuner_device.h:37
InAnalogTunerPort(std::string port_name, analog_tuner_delegation *_parent)
Definition: fe_tuner_port_impl.h:144
InFrontendTunerPort(std::string port_name, tuner_delegation *_parent)
Definition: fe_tuner_port_impl.h:100
double getTunerBandwidth(std::string &id)
Definition: fe_tuner_port_impl.h:374
void setTunerCenterFrequency(std::string &id, double freq)
Definition: fe_tuner_port_impl.h:334
void setTunerEnable(const char *id, CORBA::Boolean enable)
Definition: fe_tuner_port_impl.h:199
Definition: fe_tuner_port_impl.h:327
Definition: Port_impl.h:364
Definition: fe_tuner_port_impl.h:216
OutDigitalTunerPortT(std::string port_name)
Definition: fe_tuner_port_impl.h:502
OutDigitalTunerPort(std::string port_name)
Definition: fe_tuner_port_impl.h:558
double Double
Definition: bulkio_base.h:156
bool getTunerDeviceControl(std::string &id)
Definition: fe_tuner_port_impl.h:266
std::vector< std::pair< PortType_var, std::string > > outConnections
Definition: fe_port_impl.h:298
virtual void setTunerReferenceSource(const std::string &id, long source)
Definition: fe_tuner_port_impl.h:73
void setTunerBandwidth(const char *id, CORBA::Double bw)
Definition: fe_tuner_port_impl.h:159
virtual bool getTunerDeviceControl(const std::string &id)
Definition: fe_tuner_port_impl.h:35
virtual void setTunerAgcEnable(const std::string &id, bool enable)
Definition: fe_tuner_port_impl.h:61
void setTunerOutputSampleRate(std::string &id, double sr)
Definition: fe_tuner_port_impl.h:506
char * getTunerGroupId(const char *id)
Definition: fe_tuner_port_impl.h:116
virtual std::string getTunerGroupId(const std::string &id)
Definition: fe_tuner_port_impl.h:38
OutAnalogTunerPortT(std::string port_name)
Definition: fe_tuner_port_impl.h:330
void setTunerGain(const char *id, CORBA::Float gain)
Definition: fe_tuner_port_impl.h:179
bool getTunerAgcEnable(std::string &id)
Definition: fe_tuner_port_impl.h:401
virtual long getTunerReferenceSource(const std::string &id)
Definition: fe_tuner_port_impl.h:76
CORBA::Float getTunerGain(const char *id)
Definition: fe_tuner_port_impl.h:184
int getTunerReferenceSource(std::string &id)
Definition: fe_tuner_port_impl.h:455
CORBA::Long getTunerReferenceSource(const char *id)
Definition: fe_tuner_port_impl.h:194
Definition: fe_tuner_port_impl.h:140
OutAnalogTunerPort(std::string port_name)
Definition: fe_tuner_port_impl.h:549
std::string getTunerRfFlowId(std::string &id)
Definition: fe_tuner_port_impl.h:295
~InAnalogTunerPort()
Definition: fe_tuner_port_impl.h:148
virtual float getTunerGain(const std::string &id)
Definition: fe_tuner_port_impl.h:70
void setTunerReferenceSource(std::string &id, int source)
Definition: fe_tuner_port_impl.h:442
CORBA::Boolean getTunerDeviceControl(const char *id)
Definition: fe_tuner_port_impl.h:111
CF::Properties * getTunerStatus(const char *id)
Definition: fe_tuner_port_impl.h:126
Definition: fe_tuner_port_impl.h:556
std::string getTunerType(std::string &id)
Definition: fe_tuner_port_impl.h:251
boost::mutex portAccess
Definition: fe_tuner_port_impl.h:133
CORBA::Boolean getTunerEnable(const char *id)
Definition: fe_tuner_port_impl.h:204
void setTunerAgcEnable(std::string &id, bool enable)
Definition: fe_tuner_port_impl.h:388
CORBA::Double getTunerCenterFrequency(const char *id)
Definition: fe_tuner_port_impl.h:154
Definition: fe_tuner_port_impl.h:97
CORBA::Double getTunerBandwidth(const char *id)
Definition: fe_tuner_port_impl.h:164
virtual double getTunerCenterFrequency(const std::string &id)
Definition: fe_tuner_port_impl.h:52
Definition: fe_tuner_port_impl.h:47
virtual double getTunerBandwidth(const std::string &id)
Definition: fe_tuner_port_impl.h:58
std::string getRepid() const
Definition: fe_tuner_port_impl.h:235
void setTunerBandwidth(std::string &id, double bw)
Definition: fe_tuner_port_impl.h:361
Definition: fe_tuner_port_impl.h:244
~OutDigitalTunerPortT()
Definition: fe_tuner_port_impl.h:504
InFrontendTunerPort super
Definition: fe_tuner_port_impl.h:143
CF::Properties * getTunerStatus(std::string &id)
Definition: fe_tuner_port_impl.h:310
void setTunerCenterFrequency(const char *id, CORBA::Double freq)
Definition: fe_tuner_port_impl.h:149
float Float
Definition: bulkio_base.h:155
std::string getTunerGroupId(std::string &id)
Definition: fe_tuner_port_impl.h:280
Definition: fe_tuner_port_impl.h:538
virtual void setTunerCenterFrequency(const std::string &id, double freq)
Definition: fe_tuner_port_impl.h:49
CORBA::Double getTunerOutputSampleRate(const char *id)
Definition: fe_tuner_port_impl.h:230
OutFrontendTunerPortT(std::string port_name)
Definition: fe_tuner_port_impl.h:247
~OutFrontendTunerPortT()
Definition: fe_tuner_port_impl.h:249
bool getTunerEnable(std::string &id)
Definition: fe_tuner_port_impl.h:482
virtual void setTunerEnable(const std::string &id, bool enable)
Definition: fe_tuner_port_impl.h:79
OutFrontendTunerPort(std::string port_name)
Definition: fe_tuner_port_impl.h:540
bool active
Definition: Port_impl.h:359
std::string getRepid() const
Definition: fe_tuner_port_impl.h:209
virtual void setTunerGain(const std::string &id, float gain)
Definition: fe_tuner_port_impl.h:67
void setTunerEnable(std::string &id, bool enable)
Definition: fe_tuner_port_impl.h:469
virtual void setTunerBandwidth(const std::string &id, double bw)
Definition: fe_tuner_port_impl.h:55
double getTunerOutputSampleRate(std::string &id)
Definition: fe_tuner_port_impl.h:519
virtual std::string getTunerType(const std::string &id)
Definition: fe_tuner_port_impl.h:32
virtual bool getTunerAgcEnable(const std::string &id)
Definition: fe_tuner_port_impl.h:64
void setTunerGain(std::string &id, float gain)
Definition: fe_tuner_port_impl.h:415
virtual double getTunerOutputSampleRate(const std::string &id)
Definition: fe_tuner_port_impl.h:92
std::string getRepid() const
Definition: fe_tuner_port_impl.h:131
InAnalogTunerPort super
Definition: fe_tuner_port_impl.h:219
double getTunerCenterFrequency(std::string &id)
Definition: fe_tuner_port_impl.h:347
void setTunerAgcEnable(const char *id, CORBA::Boolean enable)
Definition: fe_tuner_port_impl.h:169
char * getTunerType(const char *id)
Definition: fe_tuner_port_impl.h:106
virtual bool getTunerEnable(const std::string &id)
Definition: fe_tuner_port_impl.h:82
Definition: fe_tuner_port_impl.h:547
CORBA::Boolean getTunerAgcEnable(const char *id)
Definition: fe_tuner_port_impl.h:174
void setTunerOutputSampleRate(const char *id, CORBA::Double sr)
Definition: fe_tuner_port_impl.h:225
Definition: fe_port_impl.h:238