typedefs.hpp
Go to the documentation of this file.
1 // *****************************************************************************
2 //
3 // © Copyright 2020, Septentrio NV/SA.
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are met:
8 // 1. Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // 2. Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // 3. Neither the name of the copyright holder nor the names of its
14 // contributors may be used to endorse or promote products derived
15 // from this software without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
21 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 // POSSIBILITY OF SUCH DAMAGE.
28 //
29 // *****************************************************************************
30 
31 #pragma once
32 
33 // std includes
34 #include <numeric>
35 #include <unordered_map>
36 // ROS includes
37 #include <ros/ros.h>
38 // tf2 includes
39 #include <tf2_eigen/tf2_eigen.h>
43 // ROS msg includes
44 #include <diagnostic_msgs/DiagnosticArray.h>
45 #include <diagnostic_msgs/DiagnosticStatus.h>
46 #include <geometry_msgs/PoseWithCovarianceStamped.h>
47 #include <geometry_msgs/Quaternion.h>
48 #include <geometry_msgs/TwistWithCovarianceStamped.h>
49 #include <gps_common/GPSFix.h>
50 #include <nav_msgs/Odometry.h>
51 #include <sensor_msgs/Imu.h>
52 #include <sensor_msgs/NavSatFix.h>
53 #include <sensor_msgs/TimeReference.h>
54 // GNSS msg includes
55 #include <septentrio_gnss_driver/AttCovEuler.h>
56 #include <septentrio_gnss_driver/AttEuler.h>
57 #include <septentrio_gnss_driver/BaseVectorCart.h>
58 #include <septentrio_gnss_driver/BaseVectorGeod.h>
59 #include <septentrio_gnss_driver/BlockHeader.h>
60 #include <septentrio_gnss_driver/MeasEpoch.h>
61 #include <septentrio_gnss_driver/MeasEpochChannelType1.h>
62 #include <septentrio_gnss_driver/MeasEpochChannelType2.h>
63 #include <septentrio_gnss_driver/PVTCartesian.h>
64 #include <septentrio_gnss_driver/PVTGeodetic.h>
65 #include <septentrio_gnss_driver/PosCovCartesian.h>
66 #include <septentrio_gnss_driver/PosCovGeodetic.h>
67 #include <septentrio_gnss_driver/ReceiverTime.h>
68 #include <septentrio_gnss_driver/VectorInfoCart.h>
69 #include <septentrio_gnss_driver/VectorInfoGeod.h>
70 #include <septentrio_gnss_driver/VelCovCartesian.h>
71 #include <septentrio_gnss_driver/VelCovGeodetic.h>
72 // NMEA msg includes
73 #include <nmea_msgs/Gpgga.h>
74 #include <nmea_msgs/Gpgsa.h>
75 #include <nmea_msgs/Gpgsv.h>
76 #include <nmea_msgs/Gprmc.h>
77 // INS msg includes
78 #include <septentrio_gnss_driver/ExtSensorMeas.h>
79 #include <septentrio_gnss_driver/IMUSetup.h>
80 #include <septentrio_gnss_driver/INSNavCart.h>
81 #include <septentrio_gnss_driver/INSNavGeod.h>
82 #include <septentrio_gnss_driver/VelSensorSetup.h>
83 // Rosaic includes
86 
87 // Timestamp in nanoseconds (Unix epoch)
88 typedef uint64_t Timestamp;
89 // ROS timestamp
91 
92 // ROS messages
93 typedef diagnostic_msgs::DiagnosticArray DiagnosticArrayMsg;
94 typedef diagnostic_msgs::DiagnosticStatus DiagnosticStatusMsg;
95 typedef geometry_msgs::Quaternion QuaternionMsg;
96 typedef geometry_msgs::PoseWithCovarianceStamped PoseWithCovarianceStampedMsg;
97 typedef geometry_msgs::TwistWithCovarianceStamped TwistWithCovarianceStampedMsg;
98 typedef geometry_msgs::TransformStamped TransformStampedMsg;
99 typedef gps_common::GPSFix GPSFixMsg;
100 typedef gps_common::GPSStatus GPSStatusMsg;
101 typedef sensor_msgs::NavSatFix NavSatFixMsg;
102 typedef sensor_msgs::NavSatStatus NavSatStatusMsg;
103 typedef sensor_msgs::TimeReference TimeReferenceMsg;
104 typedef sensor_msgs::Imu ImuMsg;
105 typedef nav_msgs::Odometry LocalizationUtmMsg;
106 
107 // Septentrio GNSS SBF messages
108 typedef septentrio_gnss_driver::BaseVectorCart BaseVectorCartMsg;
109 typedef septentrio_gnss_driver::BaseVectorGeod BaseVectorGeodMsg;
110 typedef septentrio_gnss_driver::BlockHeader BlockHeaderMsg;
111 typedef septentrio_gnss_driver::MeasEpoch MeasEpochMsg;
112 typedef septentrio_gnss_driver::MeasEpochChannelType1 MeasEpochChannelType1Msg;
113 typedef septentrio_gnss_driver::MeasEpochChannelType2 MeasEpochChannelType2Msg;
114 typedef septentrio_gnss_driver::AttCovEuler AttCovEulerMsg;
115 typedef septentrio_gnss_driver::AttEuler AttEulerMsg;
116 typedef septentrio_gnss_driver::PVTCartesian PVTCartesianMsg;
117 typedef septentrio_gnss_driver::PVTGeodetic PVTGeodeticMsg;
118 typedef septentrio_gnss_driver::PosCovCartesian PosCovCartesianMsg;
119 typedef septentrio_gnss_driver::PosCovGeodetic PosCovGeodeticMsg;
120 typedef septentrio_gnss_driver::ReceiverTime ReceiverTimeMsg;
121 typedef septentrio_gnss_driver::VectorInfoCart VectorInfoCartMsg;
122 typedef septentrio_gnss_driver::VectorInfoGeod VectorInfoGeodMsg;
123 typedef septentrio_gnss_driver::VelCovCartesian VelCovCartesianMsg;
124 typedef septentrio_gnss_driver::VelCovGeodetic VelCovGeodeticMsg;
125 
126 // NMEA messages
127 typedef nmea_msgs::Gpgga GpggaMsg;
128 typedef nmea_msgs::Gpgsa GpgsaMsg;
129 typedef nmea_msgs::Gpgsv GpgsvMsg;
130 typedef nmea_msgs::Gprmc GprmcMsg;
131 
132 // Septentrio INS+GNSS SBF messages
133 typedef septentrio_gnss_driver::INSNavCart INSNavCartMsg;
134 typedef septentrio_gnss_driver::INSNavGeod INSNavGeodMsg;
135 typedef septentrio_gnss_driver::IMUSetup IMUSetupMsg;
136 typedef septentrio_gnss_driver::VelSensorSetup VelSensorSetupMsg;
137 typedef septentrio_gnss_driver::ExtSensorMeas ExtSensorMeasMsg;
138 
145 {
146  TimestampRos tsr;
147  tsr.fromNSec(ts);
148  return tsr;
149 }
150 
156 inline Timestamp timestampFromRos(const TimestampRos& tsr) { return tsr.toNSec(); }
157 
162 {
168 };
169 
175 {
176 public:
177  ROSaicNodeBase() : pNh_(new ros::NodeHandle("~")), tfListener_(tfBuffer_) {}
178 
179  virtual ~ROSaicNodeBase() {}
180 
182  {
183  ros::NodeHandle nh;
184  if (settings_.ins_vsm_ros_source == "odometry")
185  odometrySubscriber_ = nh.subscribe<nav_msgs::Odometry>(
186  "odometry_vsm", 10, &ROSaicNodeBase::callbackOdometry, this);
187  else if (settings_.ins_vsm_ros_source == "twist")
189  "twist_vsm", 10, &ROSaicNodeBase::callbackTwist, this);
190  }
191 
200  bool getUint32Param(const std::string& name, uint32_t& val, uint32_t defaultVal)
201  {
202  int32_t tempVal;
203  if ((!pNh_->getParam(name, tempVal)) || (tempVal < 0))
204  {
205  val = defaultVal;
206  return false;
207  }
208  val = tempVal;
209  return true;
210  }
211 
220  template <typename T>
221  bool param(const std::string& name, T& val, const T& defaultVal)
222  {
223  return pNh_->param(name, val, defaultVal);
224  };
225 
231  void log(LogLevel logLevel, const std::string& s)
232  {
233  switch (logLevel)
234  {
235  case LogLevel::DEBUG:
237  break;
238  case LogLevel::INFO:
240  break;
241  case LogLevel::WARN:
243  break;
244  case LogLevel::ERROR:
246  break;
247  case LogLevel::FATAL:
249  break;
250  default:
251  break;
252  }
253  }
254 
260 
266  template <typename M>
267  void publishMessage(const std::string& topic, const M& msg)
268  {
269  auto it = topicMap_.find(topic);
270  if (it != topicMap_.end())
271  {
272  it->second.publish(msg);
273  } else
274  {
275  ros::Publisher pub = pNh_->advertise<M>(topic, queueSize_);
276  topicMap_.insert(std::make_pair(topic, pub));
277  pub.publish(msg);
278  }
279  }
280 
285  void publishTf(const LocalizationUtmMsg& loc)
286  {
287  if (std::isnan(loc.pose.pose.orientation.w))
288  return;
289 
290  if (lastTfStamp_ == loc.header.stamp)
291  return;
292  lastTfStamp_ = loc.header.stamp;
293 
294  geometry_msgs::TransformStamped transformStamped;
295  transformStamped.header.stamp = loc.header.stamp;
296  transformStamped.header.frame_id = loc.header.frame_id;
297  transformStamped.child_frame_id = loc.child_frame_id;
298  transformStamped.transform.translation.x = loc.pose.pose.position.x;
299  transformStamped.transform.translation.y = loc.pose.pose.position.y;
300  transformStamped.transform.translation.z = loc.pose.pose.position.z;
301  transformStamped.transform.rotation.x = loc.pose.pose.orientation.x;
302  transformStamped.transform.rotation.y = loc.pose.pose.orientation.y;
303  transformStamped.transform.rotation.z = loc.pose.pose.orientation.z;
304  transformStamped.transform.rotation.w = loc.pose.pose.orientation.w;
305 
307  {
308  geometry_msgs::TransformStamped T_l_b;
309  try
310  {
311  // try to get tf at timestamp of message
312  T_l_b = tfBuffer_.lookupTransform(
313  loc.child_frame_id, settings_.local_frame_id, lastTfStamp_);
314  } catch (const tf2::TransformException& ex)
315  {
316  try
317  {
319  10.0,
321  << ": No transform for insertion of local frame at t="
322  << lastTfStamp_.toNSec()
323  << ". Exception: " << std::string(ex.what()));
324  // try to get latest tf
325  T_l_b = tfBuffer_.lookupTransform(
326  loc.child_frame_id, settings_.local_frame_id, ros::Time(0));
327  } catch (const tf2::TransformException& ex)
328  {
330  10.0,
332  << ": No most recent transform for insertion of local frame. Exception: "
333  << std::string(ex.what()));
334  return;
335  }
336  }
337 
338  // T_l_g = T_b_g * T_l_b;
339  transformStamped =
340  tf2::eigenToTransform(tf2::transformToEigen(transformStamped) *
341  tf2::transformToEigen(T_l_b));
342  transformStamped.header.stamp = loc.header.stamp;
343  transformStamped.header.frame_id = loc.header.frame_id;
344  transformStamped.child_frame_id = settings_.local_frame_id;
345  }
346 
347  tf2Publisher_.sendTransform(transformStamped);
348  }
349 
350 private:
351  void callbackOdometry(const nav_msgs::Odometry::ConstPtr& odo)
352  {
353  Timestamp stamp = timestampFromRos(odo->header.stamp);
354 
355  processTwist(stamp, odo->twist);
356  }
357 
358  void callbackTwist(const TwistWithCovarianceStampedMsg::ConstPtr& twist)
359  {
360  Timestamp stamp = timestampFromRos(twist->header.stamp);
361 
362  processTwist(stamp, twist->twist);
363  }
364 
366  const geometry_msgs::TwistWithCovariance& twist)
367  {
368  time_t epochSeconds = stamp / 1000000000;
369  struct tm* tm_temp = std::gmtime(&epochSeconds);
370  std::stringstream timeUtc;
371  timeUtc << std::setfill('0') << std::setw(2)
372  << std::to_string(tm_temp->tm_hour) << std::setw(2)
373  << std::to_string(tm_temp->tm_min) << std::setw(2)
374  << std::to_string(tm_temp->tm_sec) << "." << std::setw(3)
375  << std::to_string((stamp - (stamp / 1000000000) * 1000000000) /
376  1000000);
377 
378  std::string v_x;
379  std::string v_y;
380  std::string v_z;
381  std::string std_x;
382  std::string std_y;
383  std::string std_z;
385  {
386  v_x = string_utilities::trimDecimalPlaces(twist.twist.linear.x);
390  else if (twist.covariance[0] > 0.0)
392  std::sqrt(twist.covariance[0]));
393  else
394  {
395  ROS_ERROR_STREAM("Invalid covariance value for v_x: "
396  << std::to_string(twist.covariance[0])
397  << ". Ignoring measurement.");
398  }
399  } else
400  std_x = std::to_string(1000000.0);
402  {
404  v_y = "-";
405  v_y += string_utilities::trimDecimalPlaces(twist.twist.linear.y);
409  else if (twist.covariance[7] > 0.0)
411  std::sqrt(twist.covariance[7]));
412  else
413  {
414  ROS_ERROR_STREAM("Invalid covariance value for v_y: "
415  << std::to_string(twist.covariance[1])
416  << ". Ignoring measurement.");
417  v_y = "";
418  std_y = string_utilities::trimDecimalPlaces(1000000.0);
419  }
420  } else
421  std_y = string_utilities::trimDecimalPlaces(1000000.0);
423  {
425  v_z = "-";
426  v_z += string_utilities::trimDecimalPlaces(twist.twist.linear.z);
430  else if (twist.covariance[14] > 0.0)
432  std::sqrt(twist.covariance[14]));
433  else
434  {
435  ROS_ERROR_STREAM("Invalid covariance value for v_z: "
436  << std::to_string(twist.covariance[2])
437  << ". Ignoring measurement.");
438  v_z = "";
439  std_z = string_utilities::trimDecimalPlaces(1000000.0);
440  }
441  } else
442  std_z = string_utilities::trimDecimalPlaces(1000000.0);
443 
444  std::string velNmea = "$PSSN,VSM," + timeUtc.str() + "," + v_x + "," + v_y +
445  "," + std_x + "," + std_y + "," + v_z + "," + std_z;
446 
447  char crc = std::accumulate(velNmea.begin() + 1, velNmea.end(), 0,
448  [](char sum, char ch) { return sum ^ ch; });
449 
450  std::stringstream crcss;
451  crcss << std::hex << static_cast<int32_t>(crc);
452 
453  velNmea += "*" + crcss.str() + "\r\n";
454  sendVelocity(velNmea);
455  }
456 
457 protected:
459  std::shared_ptr<ros::NodeHandle> pNh_;
463  virtual void sendVelocity(const std::string& velNmea) = 0;
464 
465 private:
467  std::unordered_map<std::string, ros::Publisher> topicMap_;
469  uint32_t queueSize_ = 1;
480  // tf listener
482 };
VectorInfoGeodMsg
septentrio_gnss_driver::VectorInfoGeod VectorInfoGeodMsg
Definition: typedefs.hpp:122
ROSaicNodeBase::tfListener_
tf2_ros::TransformListener tfListener_
Definition: typedefs.hpp:481
Timestamp
uint64_t Timestamp
Definition: typedefs.hpp:88
ROSaicNodeBase::registerSubscriber
void registerSubscriber()
Definition: typedefs.hpp:181
timestampFromRos
Timestamp timestampFromRos(const TimestampRos &tsr)
Convert ROS timestamp to nsec timestamp.
Definition: typedefs.hpp:156
Settings::local_frame_id
std::string local_frame_id
Frame id of the local frame to be inserted.
Definition: settings.h:255
ros::Publisher
ROS_ERROR_STREAM
#define ROS_ERROR_STREAM(args)
settings.h
GpgsvMsg
nmea_msgs::Gpgsv GpgsvMsg
Definition: typedefs.hpp:129
ROSaicNodeBase::getTime
Timestamp getTime()
Gets current timestamp.
Definition: typedefs.hpp:259
Settings::insert_local_frame
bool insert_local_frame
Wether local frame should be inserted into tf.
Definition: settings.h:253
NavSatFixMsg
sensor_msgs::NavSatFix NavSatFixMsg
Definition: typedefs.hpp:101
tf2_eigen.h
s
XmlRpcServer s
ros
ROS_FATAL_STREAM
#define ROS_FATAL_STREAM(args)
ros.h
TwistWithCovarianceStampedMsg
geometry_msgs::TwistWithCovarianceStamped TwistWithCovarianceStampedMsg
Definition: typedefs.hpp:97
ROSaicNodeBase::processTwist
void processTwist(Timestamp stamp, const geometry_msgs::TwistWithCovariance &twist)
Definition: typedefs.hpp:365
BlockHeaderMsg
septentrio_gnss_driver::BlockHeader BlockHeaderMsg
Definition: typedefs.hpp:110
timestampToRos
TimestampRos timestampToRos(Timestamp ts)
Convert nsec timestamp to ROS timestamp.
Definition: typedefs.hpp:144
NavSatStatusMsg
sensor_msgs::NavSatStatus NavSatStatusMsg
Definition: typedefs.hpp:102
ERROR
@ ERROR
Definition: typedefs.hpp:166
ROSaicNodeBase::odometrySubscriber_
ros::Subscriber odometrySubscriber_
Odometry subscriber.
Definition: typedefs.hpp:473
ROSaicNodeBase::publishMessage
void publishMessage(const std::string &topic, const M &msg)
Publishing function.
Definition: typedefs.hpp:267
VelCovGeodeticMsg
septentrio_gnss_driver::VelCovGeodetic VelCovGeodeticMsg
Definition: typedefs.hpp:124
ReceiverTimeMsg
septentrio_gnss_driver::ReceiverTime ReceiverTimeMsg
Definition: typedefs.hpp:120
ROS_DEBUG_STREAM
#define ROS_DEBUG_STREAM(args)
INSNavCartMsg
septentrio_gnss_driver::INSNavCart INSNavCartMsg
Definition: typedefs.hpp:133
ros::Publisher::publish
void publish(const boost::shared_ptr< M > &message) const
ROSaicNodeBase::publishTf
void publishTf(const LocalizationUtmMsg &loc)
Publishing function for tf.
Definition: typedefs.hpp:285
ROSaicNodeBase
This class is the base class for abstraction.
Definition: typedefs.hpp:174
TimeReferenceMsg
sensor_msgs::TimeReference TimeReferenceMsg
Definition: typedefs.hpp:103
Settings::ins_vsm_ros_variances_by_parameter
bool ins_vsm_ros_variances_by_parameter
Whether or not to use variance defined by ROS parameter.
Definition: settings.h:290
transform_broadcaster.h
tf2::eigenToTransform
geometry_msgs::TransformStamped eigenToTransform(const Eigen::Affine3d &T)
INFO
@ INFO
Definition: typedefs.hpp:164
ROSaicNodeBase::topicMap_
std::unordered_map< std::string, ros::Publisher > topicMap_
Map of topics and publishers.
Definition: typedefs.hpp:467
tf2_ros::TransformListener
PVTGeodeticMsg
septentrio_gnss_driver::PVTGeodetic PVTGeodeticMsg
Definition: typedefs.hpp:117
PosCovGeodeticMsg
septentrio_gnss_driver::PosCovGeodetic PosCovGeodeticMsg
Definition: typedefs.hpp:119
ROS_WARN_STREAM
#define ROS_WARN_STREAM(args)
ROSaicNodeBase::getUint32Param
bool getUint32Param(const std::string &name, uint32_t &val, uint32_t defaultVal)
Gets an integer or unsigned integer value from the parameter server.
Definition: typedefs.hpp:200
ROS_WARN_STREAM_THROTTLE
#define ROS_WARN_STREAM_THROTTLE(period, args)
MeasEpochChannelType1Msg
septentrio_gnss_driver::MeasEpochChannelType1 MeasEpochChannelType1Msg
Definition: typedefs.hpp:112
tf2_ros::TransformBroadcaster::sendTransform
void sendTransform(const geometry_msgs::TransformStamped &transform)
ROSaicNodeBase::sendVelocity
virtual void sendVelocity(const std::string &velNmea)=0
Send velocity to communication layer (virtual)
LocalizationUtmMsg
nav_msgs::Odometry LocalizationUtmMsg
Definition: typedefs.hpp:105
Settings::ins_vsm_ros_config
std::vector< bool > ins_vsm_ros_config
Whether or not to use individual elements of 3D velocity (v_x, v_y, v_z)
Definition: settings.h:288
PVTCartesianMsg
septentrio_gnss_driver::PVTCartesian PVTCartesianMsg
Definition: typedefs.hpp:116
ROS_INFO_STREAM_THROTTLE
#define ROS_INFO_STREAM_THROTTLE(period, args)
string_utilities.h
Declares lower-level string utility functions used when parsing messages.
VelCovCartesianMsg
septentrio_gnss_driver::VelCovCartesian VelCovCartesianMsg
Definition: typedefs.hpp:123
Settings::use_ros_axis_orientation
bool use_ros_axis_orientation
ROS axis orientation, body: front-left-up, geographic: ENU.
Definition: settings.h:146
PosCovCartesianMsg
septentrio_gnss_driver::PosCovCartesian PosCovCartesianMsg
Definition: typedefs.hpp:118
GPSFixMsg
gps_common::GPSFix GPSFixMsg
Definition: typedefs.hpp:99
string_utilities::trimDecimalPlaces
std::string trimDecimalPlaces(double num)
Trims decimal places to two.
Definition: string_utilities.cpp:186
GPSStatusMsg
gps_common::GPSStatus GPSStatusMsg
Definition: typedefs.hpp:100
AttCovEulerMsg
septentrio_gnss_driver::AttCovEuler AttCovEulerMsg
Definition: typedefs.hpp:114
GpggaMsg
nmea_msgs::Gpgga GpggaMsg
Definition: typedefs.hpp:127
DEBUG
@ DEBUG
Definition: typedefs.hpp:163
ROSaicNodeBase::callbackOdometry
void callbackOdometry(const nav_msgs::Odometry::ConstPtr &odo)
Definition: typedefs.hpp:351
ROSaicNodeBase::ROSaicNodeBase
ROSaicNodeBase()
Definition: typedefs.hpp:177
tf2_ros::Buffer
INSNavGeodMsg
septentrio_gnss_driver::INSNavGeod INSNavGeodMsg
Definition: typedefs.hpp:134
ros::NodeHandle::subscribe
Subscriber subscribe(const std::string &topic, uint32_t queue_size, const boost::function< void(C)> &callback, const VoidConstPtr &tracked_object=VoidConstPtr(), const TransportHints &transport_hints=TransportHints())
ROS_INFO_STREAM
#define ROS_INFO_STREAM(args)
ROSaicNodeBase::param
bool param(const std::string &name, T &val, const T &defaultVal)
Gets parameter of type T from the parameter server.
Definition: typedefs.hpp:221
TransformStampedMsg
geometry_msgs::TransformStamped TransformStampedMsg
Definition: typedefs.hpp:98
DiagnosticStatusMsg
diagnostic_msgs::DiagnosticStatus DiagnosticStatusMsg
Definition: typedefs.hpp:94
ROSaicNodeBase::settings_
Settings settings_
Settings.
Definition: typedefs.hpp:461
tf2::transformToEigen
Eigen::Isometry3d transformToEigen(const geometry_msgs::Transform &t)
Settings
Settings struct.
Definition: settings.h:103
ROSaicNodeBase::tf2Publisher_
tf2_ros::TransformBroadcaster tf2Publisher_
Transform publisher.
Definition: typedefs.hpp:471
ros::this_node::getName
const ROSCPP_DECL std::string & getName()
transform_listener.h
ExtSensorMeasMsg
septentrio_gnss_driver::ExtSensorMeas ExtSensorMeasMsg
Definition: typedefs.hpp:137
ROSaicNodeBase::twistSubscriber_
ros::Subscriber twistSubscriber_
Twist subscriber.
Definition: typedefs.hpp:475
FATAL
@ FATAL
Definition: typedefs.hpp:167
ROSaicNodeBase::callbackTwist
void callbackTwist(const TwistWithCovarianceStampedMsg::ConstPtr &twist)
Definition: typedefs.hpp:358
TimeBase< Time, Duration >::fromNSec
Time & fromNSec(uint64_t t)
ros::Time
BaseVectorGeodMsg
septentrio_gnss_driver::BaseVectorGeod BaseVectorGeodMsg
Definition: typedefs.hpp:109
Settings::ins_vsm_ros_source
std::string ins_vsm_ros_source
VSM source for INS.
Definition: settings.h:286
ROSaicNodeBase::pNh_
std::shared_ptr< ros::NodeHandle > pNh_
Node handle pointer.
Definition: typedefs.hpp:459
ROSaicNodeBase::log
void log(LogLevel logLevel, const std::string &s)
Log function to provide abstraction of ROS loggers.
Definition: typedefs.hpp:231
GpgsaMsg
nmea_msgs::Gpgsa GpgsaMsg
Definition: typedefs.hpp:128
VectorInfoCartMsg
septentrio_gnss_driver::VectorInfoCart VectorInfoCartMsg
Definition: typedefs.hpp:121
tf2_ros::TransformBroadcaster
TimeBase< Time, Duration >::toNSec
uint64_t toNSec() const
VelSensorSetupMsg
septentrio_gnss_driver::VelSensorSetup VelSensorSetupMsg
Definition: typedefs.hpp:136
BaseVectorCartMsg
septentrio_gnss_driver::BaseVectorCart BaseVectorCartMsg
Definition: typedefs.hpp:108
tf2_geometry_msgs.h
GprmcMsg
nmea_msgs::Gprmc GprmcMsg
Definition: typedefs.hpp:130
MeasEpochMsg
septentrio_gnss_driver::MeasEpoch MeasEpochMsg
Definition: typedefs.hpp:111
ROSaicNodeBase::tfBuffer_
tf2_ros::Buffer tfBuffer_
tf buffer
Definition: typedefs.hpp:479
ROSaicNodeBase::~ROSaicNodeBase
virtual ~ROSaicNodeBase()
Definition: typedefs.hpp:179
TimestampRos
ros::Time TimestampRos
Definition: typedefs.hpp:90
Settings::ins_vsm_ros_variances
std::vector< double > ins_vsm_ros_variances
Variances of the 3D velocity (var_x, var_y, var_z)
Definition: settings.h:292
WARN
@ WARN
Definition: typedefs.hpp:165
QuaternionMsg
geometry_msgs::Quaternion QuaternionMsg
Definition: typedefs.hpp:95
MeasEpochChannelType2Msg
septentrio_gnss_driver::MeasEpochChannelType2 MeasEpochChannelType2Msg
Definition: typedefs.hpp:113
LogLevel
LogLevel
Log level for ROS logging.
Definition: typedefs.hpp:161
tf2::TransformException
ROSaicNodeBase::queueSize_
uint32_t queueSize_
Publisher queue size.
Definition: typedefs.hpp:469
ROSaicNodeBase::lastTfStamp_
TimestampRos lastTfStamp_
Last tf stamp.
Definition: typedefs.hpp:477
IMUSetupMsg
septentrio_gnss_driver::IMUSetup IMUSetupMsg
Definition: typedefs.hpp:135
tf2_ros::Buffer::lookupTransform
virtual geometry_msgs::TransformStamped lookupTransform(const std::string &target_frame, const ros::Time &target_time, const std::string &source_frame, const ros::Time &source_time, const std::string &fixed_frame, const ros::Duration timeout) const
ImuMsg
sensor_msgs::Imu ImuMsg
Definition: typedefs.hpp:104
ros::NodeHandle
ros::Subscriber
ros::Time::now
static Time now()
PoseWithCovarianceStampedMsg
geometry_msgs::PoseWithCovarianceStamped PoseWithCovarianceStampedMsg
Definition: typedefs.hpp:96
DiagnosticArrayMsg
diagnostic_msgs::DiagnosticArray DiagnosticArrayMsg
Definition: typedefs.hpp:93
AttEulerMsg
septentrio_gnss_driver::AttEuler AttEulerMsg
Definition: typedefs.hpp:115


septentrio_gnss_driver
Author(s): Tibor Dome
autogenerated on Thu Nov 10 2022 04:02:01