message_publisher.cpp
Go to the documentation of this file.
1 #include "message_publisher.h"
2 
4 
8 //---------------------------------------------------------------------//
9 //- Constructor -//
10 //---------------------------------------------------------------------//
11 
12 MessagePublisher::MessagePublisher(void):
13 m_max_messages_(10)
14 {
15 }
16 
17 //---------------------------------------------------------------------//
18 //- Private methods -//
19 //---------------------------------------------------------------------//
20 
21 std::string MessagePublisher::getOutputTopicName(SbgEComMsgId sbg_message_id) const
22 {
23  std::string sbg_node_name;
24  std::string name;
25 
26  sbg_node_name = ros::names::resolve("sbg");
27 
28  switch (sbg_message_id)
29  {
31  name = "/status";
32  break;
34  name = "/utc_time";
35  break;
37  name = "/imu_data";
38  break;
39  case SBG_ECOM_LOG_MAG:
40  name = "/mag";
41  break;
43  name = "/mag_calib";
44  break;
46  name = "/ekf_euler";
47  break;
49  name = "/ekf_quat";
50  break;
52  name = "/ekf_nav";
53  break;
55  name = "/ship_motion";
56  break;
58  name = "/gps_vel";
59  break;
61  name = "/gps_pos";
62  break;
64  name = "/gps_hdt";
65  break;
67  name = "/gps_raw";
68  break;
70  name = "/odo_vel";
71  break;
73  name = "/eventA";
74  break;
76  name = "/eventB";
77  break;
79  name = "/eventC";
80  break;
82  name = "/eventD";
83  break;
85  name = "/eventE";
86  break;
88  name = "/air_data";
89  break;
91  name = "/imu_short";
92  break;
93  default:
94  return "undefined";
95  }
96 
97  return sbg_node_name + name;
98 }
99 
100 void MessagePublisher::initPublisher(ros::NodeHandle& ref_ros_node_handle, SbgEComMsgId sbg_msg_id, SbgEComOutputMode output_conf, const std::string &ref_output_topic)
101 {
102  //
103  // Check if the publisher has to be initialized.
104  //
105  if (output_conf != SBG_ECOM_OUTPUT_MODE_DISABLED)
106  {
107  switch (sbg_msg_id)
108  {
109  case SBG_ECOM_LOG_STATUS:
110  m_sbgStatus_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgStatus>(ref_output_topic, m_max_messages_);
111  break;
112 
114  m_sbgUtcTime_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgUtcTime>(ref_output_topic, m_max_messages_);
115  break;
116 
118  m_sbgImuData_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgImuData>(ref_output_topic, m_max_messages_);
119  break;
120 
121  case SBG_ECOM_LOG_MAG:
122  m_sbgMag_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgMag>(ref_output_topic, m_max_messages_);
123  break;
124 
126  m_sbgMagCalib_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgMagCalib>(ref_output_topic, m_max_messages_);
127  break;
128 
130  m_sbgEkfEuler_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgEkfEuler>(ref_output_topic, m_max_messages_);
131  break;
132 
134  m_sbgEkfQuat_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgEkfQuat>(ref_output_topic, m_max_messages_);
135  break;
136 
138 
139  m_sbgEkfNav_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgEkfNav>(ref_output_topic, m_max_messages_);
140  break;
141 
143 
144  m_sbgShipMotion_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgShipMotion>(ref_output_topic, m_max_messages_);
145  break;
146 
149 
150  m_sbgGpsVel_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgGpsVel>(ref_output_topic, m_max_messages_);
151  break;
152 
155 
156  m_sbgGpsPos_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgGpsPos>(ref_output_topic, m_max_messages_);
157  break;
158 
161 
162  m_sbgGpsHdt_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgGpsHdt>(ref_output_topic, m_max_messages_);
163  break;
164 
167 
168  m_sbgGpsRaw_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgGpsRaw>(ref_output_topic, m_max_messages_);
169  break;
170 
172 
173  m_sbgOdoVel_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgOdoVel>(ref_output_topic, m_max_messages_);
174  break;
175 
177 
178  m_sbgEventA_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgEvent>(ref_output_topic, m_max_messages_);
179  break;
180 
182 
183  m_sbgEventB_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgEvent>(ref_output_topic, m_max_messages_);
184  break;
185 
187 
188  m_sbgEventC_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgEvent>(ref_output_topic, m_max_messages_);
189  break;
190 
192 
193  m_sbgEventD_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgEvent>(ref_output_topic, m_max_messages_);
194  break;
195 
197 
198  m_sbgEventE_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgEvent>(ref_output_topic, m_max_messages_);
199  break;
200 
202 
203  m_sbgImuShort_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgImuShort>(ref_output_topic, m_max_messages_);
204  break;
205 
207 
208  m_sbgAirData_pub_ = ref_ros_node_handle.advertise<sbg_driver::SbgAirData>(ref_output_topic, m_max_messages_);
209  break;
210 
211  default:
212  break;
213  }
214  }
215 }
216 
217 void MessagePublisher::defineRosStandardPublishers(ros::NodeHandle& ref_ros_node_handle, bool odom_enable)
218 {
219  std::string imu_node_name;
220 
221  imu_node_name = ros::names::resolve("imu");
222 
224  {
225  m_imu_pub_ = ref_ros_node_handle.advertise<sensor_msgs::Imu>(imu_node_name + "/data", m_max_messages_);
226  }
227  else
228  {
229  ROS_WARN("SBG_DRIVER - [Publisher] SBG Imu and/or Quat output are not configured, the standard IMU can not be defined.");
230  }
231 
232  if (m_sbgImuData_pub_)
233  {
234  m_temp_pub_ = ref_ros_node_handle.advertise<sensor_msgs::Temperature>(imu_node_name + "/temp", m_max_messages_);
235  }
236  else
237  {
238  ROS_WARN("SBG_DRIVER - [Publisher] SBG Imu data output are not configured, the standard Temperature publisher can not be defined.");
239  }
240 
241  if (m_sbgMag_pub_)
242  {
243  m_mag_pub_ = ref_ros_node_handle.advertise<sensor_msgs::MagneticField>(imu_node_name + "/mag", m_max_messages_);
244  }
245  else
246  {
247  ROS_WARN("SBG_DRIVER - [Publisher] SBG Mag data output are not configured, the standard Magnetic publisher can not be defined.");
248  }
249 
250  //
251  // We need either Euler or quat angles, and we must have Nav and IMU data to
252  // compute Body and angular velocity.
253  //
255  {
256  m_velocity_pub_ = ref_ros_node_handle.advertise<geometry_msgs::TwistStamped>(imu_node_name + "/velocity", m_max_messages_);
257  }
258  else
259  {
260  ROS_WARN("SBG_DRIVER - [Publisher] SBG Imu, Nav or Angles data outputs are not configured, the standard Velocity publisher can not be defined.");
261  }
262 
263  if (m_sbgAirData_pub_)
264  {
265  m_fluid_pub_ = ref_ros_node_handle.advertise<sensor_msgs::FluidPressure>(imu_node_name + "/pres", m_max_messages_);
266  }
267  else
268  {
269  ROS_WARN("SBG_DRIVER - [Publisher] SBG AirData output are not configured, the standard FluidPressure publisher can not be defined.");
270  }
271 
272  if (m_sbgEkfNav_pub_)
273  {
274  m_pos_ecef_pub_ = ref_ros_node_handle.advertise<geometry_msgs::PointStamped>(imu_node_name + "/pos_ecef", m_max_messages_);
275  }
276  else
277  {
278  ROS_WARN("SBG_DRIVER - [Publisher] SBG Ekf data output are not configured, the standard ECEF position publisher can not be defined.");
279  }
280 
281  if (m_sbgUtcTime_pub_)
282  {
283  m_utc_reference_pub_ = ref_ros_node_handle.advertise<sensor_msgs::TimeReference>(imu_node_name + "/utc_ref", m_max_messages_);
284  }
285  else
286  {
287  ROS_WARN("SBG_DRIVER - [Publisher] SBG Utc data output are not configured, the UTC time reference publisher can not be defined.");
288  }
289 
290  if (m_sbgGpsPos_pub_)
291  {
292  m_nav_sat_fix_pub_ = ref_ros_node_handle.advertise<sensor_msgs::NavSatFix>(imu_node_name + "/nav_sat_fix", m_max_messages_);
293  }
294  else
295  {
296  ROS_WARN("SBG_DRIVER - [Publisher] SBG GPS Pos data output are not configured, the NavSatFix publisher can not be defined.");
297  }
298 
299  if (odom_enable)
300  {
302  {
303  m_odometry_pub_ = ref_ros_node_handle.advertise<nav_msgs::Odometry>(imu_node_name + "/odometry", m_max_messages_);
304  }
305  else
306  {
307  ROS_WARN("SBG_DRIVER - [Publisher] SBG IMU, NAV and Quaternion (or Euler) outputs are not configured, the odometry publisher can not be defined.");
308  }
309  }
310 }
311 
313 {
314  if (m_sbgImuData_pub_)
315  {
318  }
319  if (m_temp_pub_)
320  {
322  }
323 
327 }
328 
330 {
331  if (m_velocity_pub_)
332  {
333  if (m_sbgEkfQuat_pub_)
334  {
336  }
337  else if (m_sbgEkfEuler_pub_)
338  {
340  }
341  }
342 }
343 
345 {
346  if (m_imu_pub_)
347  {
348  if (m_sbg_imu_message_.time_stamp == m_sbg_ekf_quat_message_.time_stamp)
349  {
351  }
352  }
353 }
354 
356 {
357  if (m_odometry_pub_)
358  {
359  if (m_sbg_ekf_nav_message_.status.position_valid)
360  {
361  if (m_sbg_imu_message_.time_stamp == m_sbg_ekf_nav_message_.time_stamp)
362  {
363  /*
364  * Odometry message can be generated from quaternion or euler angles.
365  * Quaternion is prefered if they are available.
366  */
367  if (m_sbgEkfQuat_pub_)
368  {
369  if (m_sbg_imu_message_.time_stamp == m_sbg_ekf_quat_message_.time_stamp)
370  {
372  }
373  }
374  else
375  {
376  if (m_sbg_imu_message_.time_stamp == m_sbg_ekf_euler_message_.time_stamp)
377  {
379  }
380  }
381  }
382  }
383  }
384 }
385 
387 {
388  sbg_driver::SbgMag sbg_mag_message;
389  sbg_mag_message = m_message_wrapper_.createSbgMagMessage(ref_sbg_log.magData);
390 
391  if (m_sbgMag_pub_)
392  {
393  m_sbgMag_pub_.publish(sbg_mag_message);
394  }
395  if (m_mag_pub_)
396  {
398  }
399 }
400 
402 {
403  sbg_driver::SbgAirData sbg_air_data_message;
404  sbg_air_data_message = m_message_wrapper_.createSbgAirDataMessage(ref_sbg_log.airData);
405 
406  if (m_sbgAirData_pub_)
407  {
408  m_sbgAirData_pub_.publish(sbg_air_data_message);
409  }
410  if (m_fluid_pub_)
411  {
413  }
414 }
415 
417 {
419 
420  if (m_sbgEkfNav_pub_)
421  {
423  }
424  if (m_pos_ecef_pub_)
425  {
427  }
429 }
430 
432 {
433  sbg_driver::SbgUtcTime sbg_utc_message;
434 
435  sbg_utc_message = m_message_wrapper_.createSbgUtcTimeMessage(ref_sbg_log.utcData);
436 
437  if (m_sbgUtcTime_pub_)
438  {
439  m_sbgUtcTime_pub_.publish(sbg_utc_message);
440  }
442  {
443  if (sbg_utc_message.clock_status.clock_utc_status != SBG_ECOM_UTC_INVALID)
444  {
446  }
447  }
448 }
449 
451 {
452  sbg_driver::SbgGpsPos sbg_gps_pos_message;
453 
454  sbg_gps_pos_message = m_message_wrapper_.createSbgGpsPosMessage(ref_sbg_log.gpsPosData);
455 
456  if (m_sbgGpsPos_pub_)
457  {
458  m_sbgGpsPos_pub_.publish(sbg_gps_pos_message);
459  }
460  if (m_nav_sat_fix_pub_)
461  {
463  }
464 }
465 
466 //---------------------------------------------------------------------//
467 //- Operations -//
468 //---------------------------------------------------------------------//
469 
470 void MessagePublisher::initPublishers(ros::NodeHandle& ref_ros_node_handle, const ConfigStore &ref_config_store)
471 {
472  //
473  // Initialize all the publishers with the defined SBG output from the config store.
474  //
475  const std::vector<ConfigStore::SbgLogOutput> &ref_output_modes = ref_config_store.getOutputModes();
476 
478 
479  m_message_wrapper_.setFrameId(ref_config_store.getFrameId());
480 
481  m_message_wrapper_.setUseEnu(ref_config_store.getUseEnu());
482 
483  m_message_wrapper_.setOdomEnable(ref_config_store.getOdomEnable());
488 
489  for (const ConfigStore::SbgLogOutput &ref_output : ref_output_modes)
490  {
491  initPublisher(ref_ros_node_handle, ref_output.message_id, ref_output.output_mode, getOutputTopicName(ref_output.message_id));
492  }
493 
494  if (ref_config_store.checkRosStandardMessages())
495  {
496  defineRosStandardPublishers(ref_ros_node_handle, ref_config_store.getOdomEnable());
497  }
498 }
499 
500 void MessagePublisher::publish(SbgEComClass sbg_msg_class, SbgEComMsgId sbg_msg_id, const SbgBinaryLogData &ref_sbg_log)
501 {
502  //
503  // Publish the message with the corresponding publisher and SBG message ID.
504  // For each log, check if the publisher has been initialized.
505  //
506  if(sbg_msg_class == SBG_ECOM_CLASS_LOG_ECOM_0)
507  {
508  switch (sbg_msg_id)
509  {
510  case SBG_ECOM_LOG_STATUS:
511 
512  if (m_sbgStatus_pub_)
513  {
515  }
516  break;
517 
519 
520  publishUtcData(ref_sbg_log);
521  break;
522 
524 
525  publishIMUData(ref_sbg_log);
526  break;
527 
528  case SBG_ECOM_LOG_MAG:
529 
530  publishMagData(ref_sbg_log);
531  break;
532 
534 
535  if (m_sbgMagCalib_pub_)
536  {
538  }
539  break;
540 
542 
543  if (m_sbgEkfEuler_pub_)
544  {
549  }
550  break;
551 
553 
554  if (m_sbgEkfQuat_pub_)
555  {
560  }
561  break;
562 
564 
565  publishEkfNavigationData(ref_sbg_log);
567  break;
568 
570 
572  {
574  }
575  break;
576 
579 
580  if (m_sbgGpsVel_pub_)
581  {
583  }
584  break;
585 
588 
589  publishGpsPosData(ref_sbg_log);
590  break;
591 
594 
595  if (m_sbgGpsHdt_pub_)
596  {
598  }
599  break;
600 
603 
604  if (m_sbgGpsRaw_pub_)
605  {
607  }
608  break;
609 
611 
612  if (m_sbgOdoVel_pub_)
613  {
615  }
616  break;
617 
619 
620  if (m_sbgEventA_pub_)
621  {
623  }
624  break;
625 
627 
628  if (m_sbgEventB_pub_)
629  {
631  }
632  break;
633 
635 
636  if (m_sbgEventC_pub_)
637  {
639  }
640  break;
641 
643 
644  if (m_sbgEventD_pub_)
645  {
647  }
648  break;
649 
651 
652  if (m_sbgEventE_pub_)
653  {
655  }
656  break;
657 
659 
660  if (m_sbgImuShort_pub_)
661  {
663  }
664  break;
665 
667 
668  publishFluidPressureData(ref_sbg_log);
669  break;
670 
671  default:
672  break;
673  }
674  }
675  else if (sbg_msg_class == SBG_ECOM_CLASS_LOG_ECOM_1)
676  {
677  switch (sbg_msg_id)
678  {
679  default:
680  break;
681  }
682  }
683 }
ros::Publisher m_sbgGpsVel_pub_
const sensor_msgs::NavSatFix createRosNavSatFixMessage(const sbg_driver::SbgGpsPos &ref_sbg_gps_msg) const
SbgLogEkfNavData ekfNavData
SbgLogEkfEulerData ekfEulerData
const sbg_driver::SbgImuShort createSbgImuShortMessage(const SbgLogImuShort &ref_short_imu_log) const
SbgLogEkfQuatData ekfQuatData
const std::string & getFrameId(void) const
const nav_msgs::Odometry createRosOdoMessage(const sbg_driver::SbgImuData &ref_sbg_imu_msg, const sbg_driver::SbgEkfNav &ref_sbg_ekf_nav_msg, const sbg_driver::SbgEkfQuat &ref_sbg_ekf_quat_msg, const sbg_driver::SbgEkfEuler &ref_sbg_ekf_euler_msg)
ros::Publisher m_imu_pub_
void setOdomEnable(bool odom_enable)
TimeReference getTimeReference(void) const
ros::Publisher m_pos_ecef_pub_
const sbg_driver::SbgEkfNav createSbgEkfNavMessage(const SbgLogEkfNavData &ref_log_ekf_nav) const
const sbg_driver::SbgAirData createSbgAirDataMessage(const SbgLogAirData &ref_air_data_log) const
const std::string & getOdomBaseFrameId(void) const
const sensor_msgs::TimeReference createRosUtcTimeReferenceMessage(const sbg_driver::SbgUtcTime &ref_sbg_utc_msg) const
const std::string & getOdomFrameId(void) const
void defineRosStandardPublishers(ros::NodeHandle &ref_ros_node_handle, bool odom_enable)
SbgLogImuData imuData
SbgLogEvent eventMarker
ros::Publisher m_sbgImuShort_pub_
void setOdomPublishTf(bool publish_tf)
bool getOdomEnable(void) const
Manage publishment of messages from logs.
const geometry_msgs::TwistStamped createRosTwistStampedMessage(const sbg::SbgVector3f &body_vel, const sbg_driver::SbgImuData &ref_sbg_imu_msg) const
MessageWrapper m_message_wrapper_
std::string getOutputTopicName(SbgEComMsgId sbg_message_id) const
ros::Publisher m_sbgImuData_pub_
void publishIMUData(const SbgBinaryLogData &ref_sbg_log)
ros::Publisher m_sbgEkfQuat_pub_
bool getOdomPublishTf(void) const
ROSCPP_DECL std::string resolve(const std::string &name, bool remap=true)
const std::string & getOdomInitFrameId(void) const
bool checkRosStandardMessages(void) const
#define ROS_WARN(...)
SbgLogGpsVel gpsVelData
const sbg_driver::SbgEkfQuat createSbgEkfQuatMessage(const SbgLogEkfQuatData &ref_log_ekf_quat) const
void publish(SbgEComClass sbg_msg_class, SbgEComMsgId sbg_msg_id, const SbgBinaryLogData &ref_sbg_log)
void publishEkfNavigationData(const SbgBinaryLogData &ref_sbg_log)
SbgLogOdometerData odometerData
const sbg_driver::SbgGpsPos createSbgGpsPosMessage(const SbgLogGpsPos &ref_log_gps_pos) const
ros::Publisher m_odometry_pub_
ros::Publisher m_sbgUtcTime_pub_
void publishMagData(const SbgBinaryLogData &ref_sbg_log)
void setFrameId(const std::string &frame_id)
void setTimeReference(TimeReference time_reference)
ros::Publisher m_sbgEventD_pub_
const sbg_driver::SbgUtcTime createSbgUtcTimeMessage(const SbgLogUtcData &ref_log_utc)
const sensor_msgs::FluidPressure createRosFluidPressureMessage(const sbg_driver::SbgAirData &ref_sbg_air_msg) const
void initPublisher(ros::NodeHandle &ref_ros_node_handle, SbgEComMsgId sbg_msg_id, SbgEComOutputMode output_conf, const std::string &ref_output_topic)
void publish(const boost::shared_ptr< M > &message) const
ros::Publisher m_sbgGpsPos_pub_
const sbg_driver::SbgShipMotion createSbgShipMotionMessage(const SbgLogShipMotionData &ref_log_ship_motion) const
ros::Publisher m_sbgEkfNav_pub_
ros::Publisher m_sbgEventB_pub_
void publishUtcData(const SbgBinaryLogData &ref_sbg_log)
sbg_driver::SbgEkfQuat m_sbg_ekf_quat_message_
const sbg_driver::SbgMagCalib createSbgMagCalibMessage(const SbgLogMagCalib &ref_log_mag_calib) const
const sbg_driver::SbgEvent createSbgEventMessage(const SbgLogEvent &ref_log_event) const
ros::Publisher m_temp_pub_
ros::Publisher m_mag_pub_
ros::Publisher m_utc_reference_pub_
SbgLogGpsPos gpsPosData
ros::Publisher m_sbgGpsRaw_pub_
const sensor_msgs::Imu createRosImuMessage(const sbg_driver::SbgImuData &ref_sbg_imu_msg, const sbg_driver::SbgEkfQuat &ref_sbg_quat_msg) const
const sbg_driver::SbgStatus createSbgStatusMessage(const SbgLogStatusData &ref_log_status) const
Publisher advertise(const std::string &topic, uint32_t queue_size, bool latch=false)
void publishGpsPosData(const SbgBinaryLogData &ref_sbg_log)
void setOdomBaseFrameId(const std::string &ref_frame_id)
ros::Publisher m_sbgEventC_pub_
ros::Publisher m_sbgMagCalib_pub_
const geometry_msgs::PointStamped createRosPointStampedMessage(const sbg_driver::SbgEkfNav &ref_sbg_ekf_msg) const
ros::Publisher m_sbgEventA_pub_
const std::vector< SbgLogOutput > & getOutputModes(void) const
SbgLogMagCalib magCalibData
SbgLogImuShort imuShort
bool getUseEnu(void) const
uint8_t SbgEComMsgId
Definition: sbgEComIds.h:289
ros::Publisher m_sbgGpsHdt_pub_
const sbg_driver::SbgImuData createSbgImuDataMessage(const SbgLogImuData &ref_log_imu_data) const
ros::Publisher m_sbgEventE_pub_
ros::Publisher m_sbgAirData_pub_
const sbg_driver::SbgEkfEuler createSbgEkfEulerMessage(const SbgLogEkfEulerData &ref_log_ekf_euler) const
ros::Publisher m_sbgShipMotion_pub_
void setOdomFrameId(const std::string &ref_frame_id)
void publishFluidPressureData(const SbgBinaryLogData &ref_sbg_log)
void setUseEnu(bool enu)
void initPublishers(ros::NodeHandle &ref_ros_node_handle, const ConfigStore &ref_config_store)
const sbg_driver::SbgGpsVel createSbgGpsVelMessage(const SbgLogGpsVel &ref_log_gps_vel) const
const sensor_msgs::Temperature createRosTemperatureMessage(const sbg_driver::SbgImuData &ref_sbg_imu_msg) const
ros::Publisher m_sbgStatus_pub_
enum _SbgEComClass SbgEComClass
const sbg_driver::SbgMag createSbgMagMessage(const SbgLogMag &ref_log_mag) const
ros::Publisher m_fluid_pub_
const sensor_msgs::MagneticField createRosMagneticMessage(const sbg_driver::SbgMag &ref_sbg_mag_msg) const
ros::Publisher m_nav_sat_fix_pub_
sbg_driver::SbgEkfEuler m_sbg_ekf_euler_message_
SbgLogShipMotionData shipMotionData
void setOdomInitFrameId(const std::string &ref_frame_id)
TimeReference
Definition: config_store.h:51
enum _SbgEComOutputMode SbgEComOutputMode
sbg_driver::SbgImuData m_sbg_imu_message_
ros::Publisher m_sbgOdoVel_pub_
const sbg_driver::SbgOdoVel createSbgOdoVelMessage(const SbgLogOdometerData &ref_log_odo) const
SbgLogAirData airData
SbgLogStatusData statusData
SbgLogUtcData utcData
sbg_driver::SbgEkfNav m_sbg_ekf_nav_message_
SbgLogGpsHdt gpsHdtData
const sbg_driver::SbgGpsHdt createSbgGpsHdtMessage(const SbgLogGpsHdt &ref_log_gps_hdt) const
const sbg_driver::SbgGpsRaw createSbgGpsRawMessage(const SbgLogGpsRaw &ref_log_gps_raw) const
ros::Publisher m_sbgEkfEuler_pub_
ros::Publisher m_velocity_pub_
ros::Publisher m_sbgMag_pub_
SbgLogGpsRaw gpsRawData


sbg_driver
Author(s): SBG Systems
autogenerated on Sat Sep 3 2022 02:53:35