fe_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_PORT_H
21 #define FE_PORT_H
22 
23 #include "ossie/Port_impl.h"
24 #include <queue>
25 #include <list>
26 #include <boost/thread/condition_variable.hpp>
27 #include <boost/thread/locks.hpp>
28 #include <boost/make_shared.hpp>
29 #include <boost/ref.hpp>
30 
31 #define CORBA_MAX_TRANSFER_BYTES omniORB::giopMaxMsgSize()
32 
33 #include <ossie/CF/QueryablePort.h>
34 
35 #include <redhawk/FRONTEND/RFInfo.h>
36 #include <redhawk/FRONTEND/GPS.h>
37 #include <redhawk/FRONTEND/NavigationData.h>
38 
39 #include <ossie/CorbaUtils.h>
40 #include "fe_types.h"
41 
42 
43 namespace frontend {
44 
45  //
46  // BEGIN FROM bulkio_p.h
47  // used for boost shared pointer instantiation when user
48  // supplied callback is provided
49  //
50  struct null_deleter
51  {
52  void operator()(void const *) const
53  {
54  }
55  };
56  // END FROM bulkio_p.h
57 
58  inline FRONTEND::RFInfoPkt* returnRFInfoPkt(const RFInfoPkt &val) {
59  FRONTEND::RFInfoPkt* tmpVal = new FRONTEND::RFInfoPkt();
60  tmpVal->rf_flow_id = CORBA::string_dup(val.rf_flow_id.c_str());
61  tmpVal->rf_center_freq = val.rf_center_freq;
62  tmpVal->rf_bandwidth = val.rf_bandwidth;
63  tmpVal->if_center_freq = val.if_center_freq;
64  tmpVal->spectrum_inverted = val.spectrum_inverted;
65  tmpVal->sensor.collector = CORBA::string_dup(val.sensor.collector.c_str());
66  tmpVal->sensor.mission = CORBA::string_dup(val.sensor.mission.c_str());
67  tmpVal->sensor.rx = CORBA::string_dup(val.sensor.rx.c_str());
68  tmpVal->sensor.antenna.description = CORBA::string_dup(val.sensor.antenna.description.c_str());
69  tmpVal->sensor.antenna.name = CORBA::string_dup(val.sensor.antenna.name.c_str());
70  tmpVal->sensor.antenna.size = CORBA::string_dup(val.sensor.antenna.size.c_str());
71  tmpVal->sensor.antenna.type = CORBA::string_dup(val.sensor.antenna.type.c_str());
72  tmpVal->sensor.feed.name = CORBA::string_dup(val.sensor.feed.name.c_str());
73  tmpVal->sensor.feed.polarization = CORBA::string_dup(val.sensor.feed.polarization.c_str());
74  tmpVal->sensor.feed.freq_range.max_val = val.sensor.feed.freq_range.max_val;
75  tmpVal->sensor.feed.freq_range.min_val = val.sensor.feed.freq_range.min_val;
76  tmpVal->sensor.feed.freq_range.values.length(val.sensor.feed.freq_range.values.size());
77  for (unsigned int i=0; i<val.sensor.feed.freq_range.values.size(); i++) {
78  tmpVal->sensor.feed.freq_range.values[i] = val.sensor.feed.freq_range.values[i];
79  }
80  return tmpVal;
81  };
82  inline RFInfoPkt returnRFInfoPkt(const FRONTEND::RFInfoPkt &tmpVal) {
83  RFInfoPkt val;
84  val.rf_flow_id = ossie::corba::returnString(tmpVal.rf_flow_id);
85  val.rf_center_freq = tmpVal.rf_center_freq;
86  val.rf_bandwidth = tmpVal.rf_bandwidth;
87  val.if_center_freq = tmpVal.if_center_freq;
88  val.spectrum_inverted = tmpVal.spectrum_inverted;
89  val.sensor.collector = ossie::corba::returnString(tmpVal.sensor.collector);
90  val.sensor.mission = ossie::corba::returnString(tmpVal.sensor.mission);
91  val.sensor.rx = ossie::corba::returnString(tmpVal.sensor.rx);
92  val.sensor.antenna.description = ossie::corba::returnString(tmpVal.sensor.antenna.description);
93  val.sensor.antenna.name = ossie::corba::returnString(tmpVal.sensor.antenna.name);
94  val.sensor.antenna.size = ossie::corba::returnString(tmpVal.sensor.antenna.size);
95  val.sensor.antenna.type = ossie::corba::returnString(tmpVal.sensor.antenna.type);
96  val.sensor.feed.name = ossie::corba::returnString(tmpVal.sensor.feed.name);
97  val.sensor.feed.polarization = ossie::corba::returnString(tmpVal.sensor.feed.polarization);
98  val.sensor.feed.freq_range.max_val = tmpVal.sensor.feed.freq_range.max_val;
99  val.sensor.feed.freq_range.min_val = tmpVal.sensor.feed.freq_range.min_val;
100  val.sensor.feed.freq_range.values.resize(tmpVal.sensor.feed.freq_range.values.length());
101  for (unsigned int i=0; i<val.sensor.feed.freq_range.values.size(); i++) {
102  val.sensor.feed.freq_range.values[i] = tmpVal.sensor.feed.freq_range.values[i];
103  }
104  return val;
105  };
106 
107  inline FRONTEND::GPSInfo* returnGPSInfo(const frontend::GPSInfo &val) {
108  FRONTEND::GPSInfo* tmpVal = new FRONTEND::GPSInfo();
109  tmpVal->source_id = CORBA::string_dup(val.source_id.c_str());
110  tmpVal->rf_flow_id = CORBA::string_dup(val.rf_flow_id.c_str());
111  tmpVal->mode = CORBA::string_dup(val.mode.c_str());
112  tmpVal->fom = val.fom;
113  tmpVal->tfom = val.tfom;
114  tmpVal->datumID = val.datumID;
115  tmpVal->time_offset = val.time_offset;
116  tmpVal->freq_offset = val.freq_offset;
117  tmpVal->time_variance = val.time_variance;
118  tmpVal->freq_variance = val.freq_variance;
119  tmpVal->satellite_count = val.satellite_count;
120  tmpVal->snr = val.snr;
121  tmpVal->status_message = CORBA::string_dup(val.status_message.c_str());
122  tmpVal->timestamp = val.timestamp;
123  tmpVal->additional_info = val.additional_info;
124  return tmpVal;
125  };
126  inline frontend::GPSInfo returnGPSInfo(const FRONTEND::GPSInfo &tmpVal) {
127  frontend::GPSInfo val;
128  val.source_id = ossie::corba::returnString(tmpVal.source_id);
129  val.rf_flow_id = ossie::corba::returnString(tmpVal.rf_flow_id);
130  val.mode = ossie::corba::returnString(tmpVal.mode);
131  val.fom = tmpVal.fom;
132  val.tfom = tmpVal.tfom;
133  val.datumID = tmpVal.datumID;
134  val.time_offset = tmpVal.time_offset;
135  val.freq_offset = tmpVal.freq_offset;
136  val.time_variance = tmpVal.time_variance;
137  val.freq_variance = tmpVal.freq_variance;
138  val.satellite_count = tmpVal.satellite_count;
139  val.snr = tmpVal.snr;
140  val.status_message = ossie::corba::returnString(tmpVal.status_message);
141  val.timestamp = tmpVal.timestamp;
142  val.additional_info = tmpVal.additional_info;
143  return val;
144  };
145 
146  inline FRONTEND::GpsTimePos* returnGpsTimePos(const frontend::GpsTimePos &val) {
147  FRONTEND::GpsTimePos* tmpVal = new FRONTEND::GpsTimePos();
148  tmpVal->position.valid = val.position.valid;
149  tmpVal->position.datum = CORBA::string_dup(val.position.datum.c_str());
150  tmpVal->position.lat = val.position.lat;
151  tmpVal->position.lon = val.position.lon;
152  tmpVal->position.alt = val.position.alt;
153  tmpVal->timestamp = val.timestamp;
154  return tmpVal;
155  };
156  inline frontend::GpsTimePos returnGpsTimePos(const FRONTEND::GpsTimePos &tmpVal) {
157  frontend::GpsTimePos val;
158  val.position.valid = tmpVal.position.valid;
159  val.position.datum = ossie::corba::returnString(tmpVal.position.datum);
160  val.position.lat = tmpVal.position.lat;
161  val.position.lon = tmpVal.position.lon;
162  val.position.alt = tmpVal.position.alt;
163  val.timestamp = tmpVal.timestamp;
164  return val;
165  };
166  inline FRONTEND::NavigationPacket* returnNavigationPacket(const frontend::NavigationPacket &val) {
167  FRONTEND::NavigationPacket* tmpVal = new FRONTEND::NavigationPacket();
168  tmpVal->source_id = CORBA::string_dup(val.source_id.c_str());
169  tmpVal->rf_flow_id = CORBA::string_dup(val.rf_flow_id.c_str());
170  tmpVal->position.valid = val.position.valid;
171  tmpVal->position.datum = CORBA::string_dup(val.position.datum.c_str());
172  tmpVal->position.lat = val.position.lat;
173  tmpVal->position.lon = val.position.lon;
174  tmpVal->position.alt = val.position.alt;
175  tmpVal->cposition.valid = val.cposition.valid;
176  tmpVal->cposition.datum = CORBA::string_dup(val.cposition.datum.c_str());
177  tmpVal->cposition.x = val.cposition.x;
178  tmpVal->cposition.y = val.cposition.y;
179  tmpVal->cposition.z = val.cposition.z;
180  tmpVal->velocity.valid = val.velocity.valid;
181  tmpVal->velocity.datum = CORBA::string_dup(val.velocity.datum.c_str());
182  tmpVal->velocity.coordinate_system = CORBA::string_dup(val.velocity.coordinate_system.c_str());
183  tmpVal->velocity.x = val.velocity.x;
184  tmpVal->velocity.y = val.velocity.y;
185  tmpVal->velocity.z = val.velocity.z;
186  tmpVal->acceleration.valid = val.acceleration.valid;
187  tmpVal->acceleration.datum = CORBA::string_dup(val.acceleration.datum.c_str());
188  tmpVal->acceleration.coordinate_system = CORBA::string_dup(val.acceleration.coordinate_system.c_str());
189  tmpVal->acceleration.x = val.acceleration.x;
190  tmpVal->acceleration.y = val.acceleration.y;
191  tmpVal->acceleration.z = val.acceleration.z;
192  tmpVal->attitude.valid = val.attitude.valid;
193  tmpVal->attitude.pitch = val.attitude.pitch;
194  tmpVal->attitude.yaw = val.attitude.yaw;
195  tmpVal->attitude.roll = val.attitude.roll;
196  tmpVal->timestamp = val.timestamp;
197  tmpVal->additional_info = val.additional_info;
198  return tmpVal;
199  };
200  inline frontend::NavigationPacket returnNavigationPacket(const FRONTEND::NavigationPacket &tmpVal) {
201  frontend::NavigationPacket val;
202  val.source_id = ossie::corba::returnString(tmpVal.source_id);
203  val.rf_flow_id = ossie::corba::returnString(tmpVal.rf_flow_id);
204  val.position.valid = tmpVal.position.valid;
205  val.position.datum = ossie::corba::returnString(tmpVal.position.datum);
206  val.position.lat = tmpVal.position.lat;
207  val.position.lon = tmpVal.position.lon;
208  val.position.alt = tmpVal.position.alt;
209  val.cposition.valid = tmpVal.cposition.valid;
210  val.cposition.datum = ossie::corba::returnString(tmpVal.cposition.datum);
211  val.cposition.x = tmpVal.cposition.x;
212  val.cposition.y = tmpVal.cposition.y;
213  val.cposition.z = tmpVal.cposition.z;
214  val.velocity.valid = tmpVal.velocity.valid;
215  val.velocity.datum = ossie::corba::returnString(tmpVal.velocity.datum);
216  val.velocity.coordinate_system = ossie::corba::returnString(tmpVal.velocity.coordinate_system);
217  val.velocity.x = tmpVal.velocity.x;
218  val.velocity.y = tmpVal.velocity.y;
219  val.velocity.z = tmpVal.velocity.z;
220  val.acceleration.valid = tmpVal.acceleration.valid;
221  val.acceleration.datum = ossie::corba::returnString(tmpVal.acceleration.datum);
222  val.acceleration.coordinate_system = ossie::corba::returnString(tmpVal.acceleration.coordinate_system);
223  val.acceleration.x = tmpVal.acceleration.x;
224  val.acceleration.y = tmpVal.acceleration.y;
225  val.acceleration.z = tmpVal.acceleration.z;
226  val.attitude.valid = tmpVal.attitude.valid;
227  val.attitude.pitch = tmpVal.attitude.pitch;
228  val.attitude.yaw = tmpVal.attitude.yaw;
229  val.attitude.roll = tmpVal.attitude.roll;
230  val.timestamp = tmpVal.timestamp;
231  val.additional_info = tmpVal.additional_info;
232  return val;
233  };
234  // ----------------------------------------------------------------------------------------
235  // OutFrontendPort declaration
236  // ----------------------------------------------------------------------------------------
237  template <typename PortType_var, typename PortType>
238  class OutFrontendPort : public Port_Uses_base_impl, public POA_ExtendedCF::QueryablePort
239  {
240  public:
241  OutFrontendPort(std::string port_name) :
242  Port_Uses_base_impl(port_name)
243  {
244  recConnectionsRefresh = false;
245  recConnections.length(0);
246  }
248  }
249 
250  ExtendedCF::UsesConnectionSequence * connections()
251  {
252  boost::mutex::scoped_lock lock(updatingPortsLock); // don't want to process while command information is coming in
253  if (recConnectionsRefresh) {
254  recConnections.length(outConnections.size());
255  for (unsigned int i = 0; i < outConnections.size(); i++) {
256  recConnections[i].connectionId = CORBA::string_dup(outConnections[i].second.c_str());
257  recConnections[i].port = CORBA::Object::_duplicate(outConnections[i].first);
258  }
259  recConnectionsRefresh = false;
260  }
261  ExtendedCF::UsesConnectionSequence_var retVal = new ExtendedCF::UsesConnectionSequence(recConnections);
262  // NOTE: You must delete the object that this function returns!
263  return retVal._retn();
264  };
265 
266  void connectPort(CORBA::Object_ptr connection, const char* connectionId)
267  {
268  boost::mutex::scoped_lock lock(updatingPortsLock); // don't want to process while command information is coming in
269  PortType_var port = PortType::_narrow(connection);
270  outConnections.push_back(std::make_pair(port, connectionId));
271  active = true;
272  recConnectionsRefresh = true;
273  };
274 
275  void disconnectPort(const char* connectionId)
276  {
277  boost::mutex::scoped_lock lock(updatingPortsLock); // don't want to process while command information is coming in
278  for (unsigned int i = 0; i < outConnections.size(); i++) {
279  if (outConnections[i].second == connectionId) {
280  outConnections.erase(outConnections.begin() + i);
281  break;
282  }
283  }
284 
285  if (outConnections.size() == 0) {
286  active = false;
287  }
288  recConnectionsRefresh = true;
289  };
290 
291  std::vector< std::pair<PortType_var, std::string> > _getConnections()
292  {
293  return outConnections;
294  };
295 
296  std::string getRepid() const {
297  return PortType::_PD_repoId;
298  };
299 
300  protected:
301  std::vector < std::pair<PortType_var, std::string> > outConnections;
302  ExtendedCF::UsesConnectionSequence recConnections;
304  };
305 
306 } // end of frontend namespace
307 
308 
309 #endif
void operator()(void const *) const
Definition: fe_port_impl.h:52
FRONTEND::GPSInfo * returnGPSInfo(const frontend::GPSInfo &val)
Definition: fe_port_impl.h:107
std::string getRepid() const
Definition: fe_port_impl.h:296
FRONTEND::RFInfoPkt * returnRFInfoPkt(const RFInfoPkt &val)
Definition: fe_port_impl.h:58
boost::mutex updatingPortsLock
Definition: Port_impl.h:360
Definition: fe_tuner_device.h:37
OutFrontendPort(std::string port_name)
Definition: fe_port_impl.h:241
std::vector< std::pair< PortType_var, std::string > > outConnections
Definition: fe_port_impl.h:298
ExtendedCF::UsesConnectionSequence recConnections
Definition: fe_port_impl.h:302
Definition: fe_port_impl.h:50
void disconnectPort(const char *connectionId)
Definition: fe_port_impl.h:275
FRONTEND::GpsTimePos * returnGpsTimePos(const frontend::GpsTimePos &val)
Definition: fe_port_impl.h:146
ExtendedCF::UsesConnectionSequence * connections()
Definition: fe_port_impl.h:250
~OutFrontendPort()
Definition: fe_port_impl.h:247
bool active
Definition: Port_impl.h:359
void connectPort(CORBA::Object_ptr connection, const char *connectionId)
Definition: fe_port_impl.h:266
bool recConnectionsRefresh
Definition: fe_port_impl.h:303
FRONTEND::NavigationPacket * returnNavigationPacket(const frontend::NavigationPacket &val)
Definition: fe_port_impl.h:166
std::vector< std::pair< PortType_var, std::string > > _getConnections()
Definition: fe_port_impl.h:291
Definition: Port_impl.h:320
Definition: fe_port_impl.h:238