apollo::drivers::lidar::HesaiComponent2类 参考

#include <hesai_component.h>

类 apollo::drivers::lidar::HesaiComponent2 继承关系图:

apollo::drivers::lidar::HesaiComponent2 的协作图:

Public 成员函数
virtual	~HesaiComponent2 ()
bool	Init () override
void	ReadScanCallback (const std::shared_ptr< HesaiUdpFrame > &scan_message) override
void	SendPointCloud (const LidarDecodedFrame< LidarPointXYZIRT > &msg)
void	SendPacket (const UdpFrame_t &hesai_raw_msg, double)
Public 成员函数 继承自 apollo::drivers::lidar::LidarComponentBase< HesaiUdpFrame >
virtual	~LidarComponentBase ()=default
bool	InitBase (const LidarConfigBase &lidar_config_base) override
bool	WriteScan (const std::shared_ptr< HesaiUdpFrame > &scan_message)
std::shared_ptr< PointCloud >	AllocatePointCloud ()
bool	WritePointCloud (const std::shared_ptr< PointCloud > &point_cloud)
Public 成员函数 继承自 apollo::drivers::lidar::LidarComponentBaseImpl< ScanType, ComponentType >
virtual	~LidarComponentBaseImpl ()=default
virtual void	ReadScanCallback (const std::shared_ptr< ScanType > &scan_message)=0
std::shared_ptr< ScanType >	AcquireScanMessage ()
Public 成员函数 继承自 apollo::cyber::Component< M0, M1, M2, M3 >
	Component ()
	~Component () override
bool	Initialize (const ComponentConfig &config) override
	init the component by protobuf object.
bool	Process (const std::shared_ptr< M0 > &msg0, const std::shared_ptr< M1 > &msg1, const std::shared_ptr< M2 > &msg2, const std::shared_ptr< M3 > &msg3)
Public 成员函数 继承自 apollo::cyber::ComponentBase
virtual	~ComponentBase ()
virtual bool	Initialize (const TimerComponentConfig &config)
virtual void	Shutdown ()
template<typename T >
bool	GetProtoConfig (T *config) const

额外继承的成员函数
Public 类型 继承自 apollo::drivers::lidar::LidarComponentBase< HesaiUdpFrame >
using	BaseComponent = LidarComponentBaseImpl< HesaiUdpFrame >
Public 类型 继承自 apollo::cyber::ComponentBase
template<typename M >
using	Reader = cyber::Reader< M >
Protected 成员函数 继承自 apollo::drivers::lidar::LidarComponentBaseImpl< ScanType, ComponentType >
bool	InitConverter (const LidarConfigBase &lidar_config_base)
bool	InitPacket (const LidarConfigBase &lidar_config_base)
virtual bool	WriteScan (const std::shared_ptr< ScanType > &scan_message)
virtual std::shared_ptr< apollo::cyber::base::ArenaQueue< PointXYZIT > >	GetPointQueue ()
Protected 成员函数 继承自 apollo::cyber::ComponentBase
virtual void	Clear ()
const std::string &	ConfigFilePath () const
void	LoadConfigFiles (const ComponentConfig &config)
void	LoadConfigFiles (const TimerComponentConfig &config)
静态 Protected 成员函数 继承自 apollo::drivers::lidar::LidarComponentBaseImpl< ScanType, ComponentType >
static void	PcdDefaultCleaner (std::shared_ptr< PointCloud > &unused_pcd_frame)
Protected 属性 继承自 apollo::drivers::lidar::LidarComponentBaseImpl< ScanType, ComponentType >
std::string	frame_id_
Protected 属性 继承自 apollo::cyber::ComponentBase
std::atomic< bool >	is_shutdown_ = {false}
std::shared_ptr< Node >	node_ = nullptr
std::string	config_file_path_ = ""
std::vector< std::shared_ptr< ReaderBase > >	readers_

详细描述

在文件 hesai_component.h 第 33 行定义.

构造及析构函数说明

~HesaiComponent2()

virtual apollo::drivers::lidar::HesaiComponent2::~HesaiComponent2 ( )

inlinevirtual

在文件 hesai_component.h 第 35 行定义.

{}

成员函数说明

Init()

bool apollo::drivers::lidar::HesaiComponent2::Init ( )

overridevirtual

实现了 apollo::drivers::lidar::LidarComponentBase< HesaiUdpFrame >.

在文件 hesai_component.cc 第 26 行定义.

                           {
    if (!GetProtoConfig(&conf_)) {
        AERROR << "load config error, file:" << config_file_path_;
        return false;
    }
    this->InitBase(conf_.config_base());
 
    if (conf_.has_convert_thread_nums()) {
        convert_threads_num_ = conf_.convert_thread_nums();
    }
 
    driver_ptr_ = std::make_shared<HesaiLidarSdk<LidarPointXYZIRT>>();
 
    DriverParam param;
    param.input_param.source_type
            = static_cast<SourceType>(conf_.source_type());
    param.input_param.pcap_path = conf_.pcap_path();
    param.input_param.correction_file_path = conf_.correction_file_path();
    param.input_param.firetimes_path = conf_.firetimes_path();
    param.input_param.device_ip_address = conf_.device_ip();
    param.input_param.host_ip_address = conf_.host_ip();
    param.input_param.ptc_port = conf_.ptc_port();
    param.input_param.udp_port = conf_.udp_port();
    param.input_param.multicast_ip_address = "";
    param.input_param.read_pcap = true;
 
    param.decoder_param.pcap_play_synchronization = false;
    param.decoder_param.frame_start_azimuth = conf_.frame_start_azimuth();
    param.decoder_param.enable_parser_thread = true;
 
    param.decoder_param.transform_param.x = 0;
    param.decoder_param.transform_param.y = 0;
    param.decoder_param.transform_param.z = 0;
    param.decoder_param.transform_param.pitch = 0;
    param.decoder_param.transform_param.yaw = 0;
    param.decoder_param.transform_param.roll = 0;
 
    param.lidar_type = conf_.lidar_type();
 
    driver_ptr_->RegRecvCallback(std::bind(
            &HesaiComponent2::SendPointCloud, this, std::placeholders::_1));
 
    if (conf_.config_base().source_type()
        == LidarConfigBase_SourceType_RAW_PACKET) {
        param.decoder_param.enable_udp_thread = false;
    }
 
    if (conf_.config_base().source_type()
        == LidarConfigBase_SourceType_ONLINE_LIDAR) {
        driver_ptr_->RegRecvCallback(std::bind(
                &HesaiComponent2::SendPacket,
                this,
                std::placeholders::_1,
                std::placeholders::_2));
    }
 
    if (!driver_ptr_->Init(param)) {
        AERROR << "init fail";
        return false;
    }
    driver_ptr_->Start();
 
    return true;
}

ReadScanCallback()

void apollo::drivers::lidar::HesaiComponent2::ReadScanCallback ( const std::shared_ptr< HesaiUdpFrame > &  scan_message )

overridevirtual

实现了 apollo::drivers::lidar::LidarComponentBase< HesaiUdpFrame >.

在文件 hesai_component.cc 第 91 行定义.

                                                          {
    // UdpPacket packet;
    // UdpFrame_t frame_t;
    for (int i = 0, packet_size = scan_message->packets_size(); i < packet_size;
         ++i) {
        driver_ptr_->lidar_ptr_->origin_packets_buffer_.emplace_back(
                reinterpret_cast<const uint8_t*>(
                        scan_message->packets(i).data().c_str()),
                scan_message->packets(i).data().length());
    }
}

SendPacket()

void apollo::drivers::lidar::HesaiComponent2::SendPacket	(	const UdpFrame_t &	hesai_raw_msg,
		double
	)

在文件 hesai_component.cc 第 143 行定义.

                          {
    std::shared_ptr<HesaiUdpFrame> udp_frame
            = std::make_shared<HesaiUdpFrame>();
 
    for (int i = 0; i < hesai_raw_msg.size(); ++i) {
        auto packet = udp_frame->add_packets();
        packet->set_timestamp_sec(timestamp);
        packet->set_size(hesai_raw_msg[i].packet_len);
        packet->mutable_data()->assign(
                reinterpret_cast<const char*>(hesai_raw_msg[i].buffer),
                reinterpret_cast<const char*>(hesai_raw_msg[i].buffer)
                        + hesai_raw_msg[i].packet_len);
    }
    this->WriteScan(udp_frame);
}

SendPointCloud()

void apollo::drivers::lidar::HesaiComponent2::SendPointCloud

(

const LidarDecodedFrame< LidarPointXYZIRT > &

msg

)

在文件 hesai_component.cc 第 104 行定义.

                                                                  {
    std::shared_ptr<PointCloud> cloud_message = this->AllocatePointCloud();
 
    cloud_message->set_is_dense(false);
    cloud_message->mutable_header()->set_timestamp_sec(
            cyber::Time().Now().ToSecond());
 
    double timestamp_diff = 0.0;
    int point_size = msg.points_num;
 
    if (point_size > 0) {
        const double pcl_timestamp = msg.points[point_size - 1].timestamp;
        cloud_message->set_measurement_time(pcl_timestamp);
        timestamp_diff = pcl_timestamp - msg.points[0].timestamp;
    } else {
        cloud_message->set_measurement_time(0.0);
    }
 
    for (int i = 0; i < point_size; ++i) {
        cloud_message->add_point();
    }
 
#pragma omp parallel for schedule(static) num_threads(convert_threads_num_)
    for (int i = 0; i < point_size; ++i) {
        cloud_message->mutable_point(i)->set_x(msg.points[i].x);
        cloud_message->mutable_point(i)->set_y(msg.points[i].y);
        cloud_message->mutable_point(i)->set_z(msg.points[i].z);
        cloud_message->mutable_point(i)->set_timestamp(
                GetNanosecondTimestampFromSecondTimestamp(
                        msg.points[i].timestamp));
        cloud_message->mutable_point(i)->set_intensity(msg.points[i].intensity);
    }
 
    AINFO << boost::format("point cnt = %d; timestamp_diff = %.9f s")
                    % point_size % timestamp_diff;
    this->WritePointCloud(cloud_message);
}

---

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

• modules/drivers/lidar/hslidar/driver/hesai_component.h
• modules/drivers/lidar/hslidar/driver/hesai_component.cc