apollo::drivers::gnss::RawStream类 参考

#include <raw_stream.h>

apollo::drivers::gnss::RawStream 的协作图:

类
struct	Status

Public 成员函数
	RawStream (const config::Config &config, const std::shared_ptr< apollo::cyber::Node > &node)
	~RawStream ()
bool	Init ()
void	Start ()

详细描述

在文件 raw_stream.h 第 38 行定义.

构造及析构函数说明

RawStream()

apollo::drivers::gnss::RawStream::RawStream	(	const config::Config &	config,
		const std::shared_ptr< apollo::cyber::Node > &	node
	)

在文件 raw_stream.cc 第 160 行定义.

    : config_(config), node_(node) {
  data_parser_ptr_.reset(new DataParser(config_, node_));
  rtcm_parser_ptr_.reset(new RtcmParser(config_, node_));
}

~RawStream()

apollo::drivers::gnss::RawStream::~RawStream

(

)

在文件 raw_stream.cc 第 167 行定义.

                      {
  this->Logout();
  this->Disconnect();
  if (gpsbin_stream_ != nullptr) {
    gpsbin_stream_->close();
  }
  if (data_thread_ptr_ != nullptr && data_thread_ptr_->joinable()) {
    data_thread_ptr_->join();
  }
  if (rtk_thread_ptr_ != nullptr && rtk_thread_ptr_->joinable()) {
    rtk_thread_ptr_->join();
  }
}

成员函数说明

Init()

bool apollo::drivers::gnss::RawStream::Init

(

)

在文件 raw_stream.cc 第 181 行定义.

                     {
  CHECK_NOTNULL(data_parser_ptr_);
  CHECK_NOTNULL(rtcm_parser_ptr_);
  if (!data_parser_ptr_->Init()) {
    AERROR << "Init data parser failed.";
    return false;
  }
  if (!rtcm_parser_ptr_->Init()) {
    AERROR << "Init rtcm parser failed.";
    return false;
  }
  stream_status_.set_ins_stream_type(StreamStatus::DISCONNECTED);
  stream_status_.set_rtk_stream_in_type(StreamStatus::DISCONNECTED);
  stream_status_.set_rtk_stream_out_type(StreamStatus::DISCONNECTED);
  stream_writer_ = node_->CreateWriter<StreamStatus>(FLAGS_stream_status_topic);
 
  common::util::FillHeader("gnss", &stream_status_);
  stream_writer_->Write(stream_status_);
 
  // Creates streams.
  Stream *s = nullptr;
  if (!config_.has_data()) {
    AINFO << "Error: Config file must provide the data stream.";
    return false;
  }
  s = create_stream(config_.data());
  if (s == nullptr) {
    AERROR << "Failed to create data stream.";
    return false;
  }
  data_stream_.reset(s);
 
  Status *status = new Status();
  if (!status) {
    AERROR << "Failed to create data stream status.";
    return false;
  }
  data_stream_status_.reset(status);
 
  if (config_.has_command()) {
    s = create_stream(config_.command());
    if (s == nullptr) {
      AERROR << "Failed to create command stream.";
      return false;
    }
    command_stream_.reset(s);
 
    status = new Status();
    if (!status) {
      AERROR << "Failed to create command stream status.";
      return false;
    }
    command_stream_status_.reset(status);
  } else {
    command_stream_ = data_stream_;
    command_stream_status_ = data_stream_status_;
  }
 
  if (config_.has_rtk_from()) {
    s = create_stream(config_.rtk_from());
    if (s == nullptr) {
      AERROR << "Failed to create rtk_from stream.";
      return false;
    }
    in_rtk_stream_.reset(s);
 
    if (config_.rtk_from().has_push_location()) {
      push_location_ = config_.rtk_from().push_location();
    }
 
    status = new Status();
    if (!status) {
      AERROR << "Failed to create rtk_from stream status.";
      return false;
    }
    in_rtk_stream_status_.reset(status);
 
    if (config_.has_rtk_to()) {
      s = create_stream(config_.rtk_to());
      if (s == nullptr) {
        AERROR << "Failed to create rtk_to stream.";
        return false;
      }
      out_rtk_stream_.reset(s);
 
      status = new Status();
      if (!status) {
        AERROR << "Failed to create rtk_to stream status.";
        return false;
      }
      out_rtk_stream_status_.reset(status);
    } else {
      out_rtk_stream_ = data_stream_;
      out_rtk_stream_status_ = data_stream_status_;
    }
 
    if (config_.has_rtk_solution_type()) {
      if (config_.rtk_solution_type() ==
          config::Config::RTK_SOFTWARE_SOLUTION) {
        rtk_software_solution_ = true;
      }
    }
  }
 
  if (config_.login_commands().empty()) {
    AWARN << "No login_commands in config file.";
  }
 
  if (config_.logout_commands().empty()) {
    AWARN << "No logout_commands in config file.";
  }
 
  // connect and login
  if (!Connect()) {
    AERROR << "gnss driver connect failed.";
    return false;
  }
 
  if (!Login()) {
    AERROR << "gnss driver login failed.";
    return false;
  }
 
  const std::string gpsbin_file = getLocalTimeFileStr(config_.gpsbin_folder());
  gpsbin_stream_.reset(new std::ofstream(
      gpsbin_file, std::ios::app | std::ios::out | std::ios::binary));
  stream_writer_ = node_->CreateWriter<StreamStatus>(FLAGS_stream_status_topic);
  raw_writer_ = node_->CreateWriter<RawData>(FLAGS_gnss_raw_data_topic);
  rtcm_writer_ = node_->CreateWriter<RawData>(FLAGS_rtcm_data_topic);
  cyber::ReaderConfig reader_config;
  reader_config.channel_name = FLAGS_gnss_raw_data_topic;
  reader_config.pending_queue_size = 100;
  gpsbin_reader_ = node_->CreateReader<RawData>(
      reader_config, [&](const std::shared_ptr<RawData> &raw_data) {
        GpsbinCallback(raw_data);
      });
  chassis_reader_ = node_->CreateReader<Chassis>(
      FLAGS_chassis_topic,
      [&](const std::shared_ptr<Chassis> &chassis) { chassis_ptr_ = chassis; });
 
  return true;
}

Start()

void apollo::drivers::gnss::RawStream::Start

(

)

在文件 raw_stream.cc 第 324 行定义.

                      {
  data_thread_ptr_.reset(new std::thread(&RawStream::DataSpin, this));
  rtk_thread_ptr_.reset(new std::thread(&RawStream::RtkSpin, this));
  if (config_.has_wheel_parameters()) {
    wheel_velocity_timer_.reset(new cyber::Timer(
        1000, [this]() { this->OnWheelVelocityTimer(); }, false));
    wheel_velocity_timer_->Start();
  }
}

---

该类的文档由以下文件生成:

• modules/drivers/gnss/stream/raw_stream.h
• modules/drivers/gnss/stream/raw_stream.cc