Namespace nebula::drivers

Namespace List > nebula > drivers

Namespaces

Type	Name
namespace	connections
namespace	loggers
namespace	point_filters

Classes

Type	Name
struct	AnglePair <typename T, typename AngleUnit>
struct	AngleRange <typename T, typename AngleUnit> A range defined by a start and end angle. Crossing the 0/circle_modulus boundary (end < start) is allowed.
struct	CANSensorConfigurationBase Base struct for CAN-based Sensor configuration.
struct	CalibrationConfigurationBase Base struct for Calibration configuration (Requires extensions in child struct)
struct	EthernetSensorConfigurationBase Base struct for Ethernet-based Sensor configuration.
struct	FieldOfView <typename T, typename AngleUnit>
struct	LidarConfigurationBase Base struct for Lidar configuration.
class	NebulaDriverBase Base class for each sensor driver.
class	NebulaHwInterfaceBase Base class for hardware interface of each LiDAR.
struct	PointXYZICATR
struct	PointXYZIR
struct	PointXYZIRADT
struct	PointXYZIRCAEDT
struct	Radians
struct	ScaledDegrees <Subdivisions>
struct	SensorConfigurationBase Base struct for Sensor configuration.

Public Types

Type	Name
typedef ScaledDegrees< 100 >	CentiDegrees
typedef ScaledDegrees< 10 >	DeciDegrees
typedef ScaledDegrees< 1 >	Degrees
typedef ScaledDegrees< 1000 >	MilliDegrees
typedef PointXYZIRCAEDT	NebulaPoint
typedef pcl::PointCloud< NebulaPoint >	NebulaPointCloud
typedef pcl::PointCloud< NebulaPoint >::Ptr	NebulaPointCloudPtr
typedef std::shared_ptr< NebulaPoint >	NebulaPointPtr
enum uint8_t	PtpProfile
enum uint8_t	PtpSwitchType
enum uint8_t	PtpTransportType
enum uint8_t	ReturnMode Return mode of each LiDAR.
enum uint8_t	ReturnType Return type of each scan.
enum uint8_t	SensorModel Type of sensor.
typedef boost::crc_ccitt_false_t	crc16_ccit_false_t CRC-16/CCITT-FALSE algorithm.
typedef boost::crc_optimal< 8, 0x2F, 0xFF, 0xFF, false, false >	crc8h2f_t AUTOSAR CRC8H2F routine.

Public Functions

Type	Name
bool	angle_is_between (T start_angle, T end_angle, T angle, bool start_inclusive=true, bool end_inclusive=true) Tests if `angle` is in the region of the circle defined by`start_angle` and`end_angle` . Notably,`end_angle` can be smaller than`start_angle` , in which case the region passes over the 360/0 deg bound. This function is unit-independent (but all angles have to have the same unit), so degrees, radians, and arbitrary scale factors can be used.
pcl::PointCloud< PointXYZIR >::Ptr	convert_point_xyziradt_to_point_xyzir (const pcl::PointCloud< PointXYZIRADT >::ConstPtr & input_pointcloud)
pcl::PointCloud< PointXYZIR >::Ptr	convert_point_xyzircaedt_to_point_xyzir (const pcl::PointCloud< PointXYZIRCAEDT >::ConstPtr & input_pointcloud)
pcl::PointCloud< PointXYZIRADT >::Ptr	convert_point_xyzircaedt_to_point_xyziradt (const pcl::PointCloud< PointXYZIRCAEDT >::ConstPtr & input_pointcloud, double stamp)
crc_type::value_type	crc (const T * begin, const U * end) Given a memory range, calculates the CRC over its bytes.
T	normalize_angle (T angle, T max_angle) Normalizes an angle to the interval [0; max_angle]. This function is unit-independent. `max_angle` is 360 for degrees, 2 M_PI for radians, and the corresponding scaled value for scaled units such as centi-degrees (36000).*
std::ostream &	operator<< (std::ostream & os, nebula::drivers::ReturnType const & arg) Convert ReturnType enum to string (Overloading the << operator)
std::ostream &	operator<< (std::ostream & os, nebula::drivers::ReturnMode const & arg) Convert ReturnMode enum to string (Overloading the << operator)
std::ostream &	operator<< (std::ostream & os, nebula::drivers::SensorModel const & arg) Convert SensorModel enum to string (Overloading the << operator)
std::ostream &	operator<< (std::ostream & os, SensorConfigurationBase const & arg) Convert SensorConfigurationBase to string (Overloading the << operator)
std::ostream &	operator<< (std::ostream & os, EthernetSensorConfigurationBase const & arg) Convert EthernetSensorConfigurationBase to string (Overloading the << operator)
std::ostream &	operator<< (std::ostream & os, CANSensorConfigurationBase const & arg) Convert CANSensorConfigurationBase to string (Overloading the << operator)
std::ostream &	operator<< (std::ostream & os, nebula::drivers::LidarConfigurationBase const & arg) Convert LidarConfigurationBase to string (Overloading the << operator)
ReturnMode	return_mode_from_string (const std::string & return_mode) Convert return mode name to ReturnMode enum.
SensorModel	sensor_model_from_string (const std::string & sensor_model) Convert sensor name to SensorModel enum (Upper and lower case letters must match)
std::string	sensor_model_to_string (const SensorModel & sensor_model)

Public Static Functions

Type	Name
float	deg2rad (double degrees) Converts degrees to radians.
float	rad2deg (double radians) Converts radians to degrees.
double	rpm2hz (double rpm) Converts RPM to Hertz.

Public Types Documentation

typedef CentiDegrees

using nebula::drivers::CentiDegrees = typedef ScaledDegrees<100>;

typedef DeciDegrees

using nebula::drivers::DeciDegrees = typedef ScaledDegrees<10>;

typedef Degrees

using nebula::drivers::Degrees = typedef ScaledDegrees<1>;

typedef MilliDegrees

using nebula::drivers::MilliDegrees = typedef ScaledDegrees<1000>;

typedef NebulaPoint

using nebula::drivers::NebulaPoint = typedef PointXYZIRCAEDT;

typedef NebulaPointCloud

using nebula::drivers::NebulaPointCloud = typedef pcl::PointCloud<NebulaPoint>;

typedef NebulaPointCloudPtr

using nebula::drivers::NebulaPointCloudPtr = typedef pcl::PointCloud<NebulaPoint>::Ptr;

typedef NebulaPointPtr

using nebula::drivers::NebulaPointPtr = typedef std::shared_ptr<NebulaPoint>;

enum PtpProfile

enum nebula::drivers::PtpProfile {
    IEEE_1588v2 = 0,
    IEEE_802_1AS,
    IEEE_802_1AS_AUTO,
    UNKNOWN_PROFILE
};

enum PtpSwitchType

enum nebula::drivers::PtpSwitchType {
    NON_TSN = 0,
    TSN,
    UNKNOWN_SWITCH
};

enum PtpTransportType

enum nebula::drivers::PtpTransportType {
    UDP_IP = 0,
    L2,
    UNKNOWN_TRANSPORT
};

enum ReturnMode

Return mode of each LiDAR.

enum nebula::drivers::ReturnMode {
    UNKNOWN = 0,
    SINGLE_STRONGEST,
    SINGLE_LAST,
    DUAL_FIRST,
    DUAL_LAST,
    DUAL_ONLY,
    SINGLE_FIRST,
    DUAL_STRONGEST_FIRST,
    DUAL_STRONGEST_LAST,
    DUAL_WEAK_FIRST,
    DUAL_WEAK_LAST,
    TRIPLE,
    LAST,
    STRONGEST,
    DUAL_LAST_STRONGEST,
    FIRST,
    DUAL_LAST_FIRST,
    DUAL_FIRST_STRONGEST,
    DUAL
};

enum ReturnType

Return type of each scan.

enum nebula::drivers::ReturnType {
    UNKNOWN = 0,
    LAST,
    FIRST,
    STRONGEST,
    FIRST_WEAK,
    LAST_WEAK,
    IDENTICAL,
    SECOND,
    SECONDSTRONGEST,
    FIRST_STRONGEST,
    LAST_STRONGEST
};

enum SensorModel

Type of sensor.

enum nebula::drivers::SensorModel {
    UNKNOWN = 0,
    HESAI_PANDAR64,
    HESAI_PANDAR40P,
    HESAI_PANDAR40M,
    HESAI_PANDARQT64,
    HESAI_PANDARQT128,
    HESAI_PANDARXT16,
    HESAI_PANDARXT32,
    HESAI_PANDARXT32M,
    HESAI_PANDARAT128,
    HESAI_PANDAR128_E3X,
    HESAI_PANDAR128_E4X,
    VELODYNE_VLS128,
    VELODYNE_HDL64,
    VELODYNE_VLP32,
    VELODYNE_VLP32MR,
    VELODYNE_HDL32,
    VELODYNE_VLP16,
    ROBOSENSE_HELIOS,
    ROBOSENSE_BPEARL_V3,
    ROBOSENSE_BPEARL_V4,
    CONTINENTAL_ARS548,
    CONTINENTAL_SRR520
};

typedef crc16_ccit_false_t

CRC-16/CCITT-FALSE algorithm.

using nebula::drivers::crc16_ccit_false_t = typedef boost::crc_ccitt_false_t;

typedef crc8h2f_t

AUTOSAR CRC8H2F routine.

using nebula::drivers::crc8h2f_t = typedef boost::crc_optimal<8, 0x2F, 0xFF, 0xFF, false, false>;

See AUTOSAR Specification of CRC Routines >=3.1.4, sec. 7.2.1.2.

Bit Width	Polynomial	Initial Value	Final XOR	Reflect In	Reflect Remainder
8	0x2F	0xFF	0xFF	false	false

Public Functions Documentation

function angle_is_between

Tests if angle is in the region of the circle defined bystart_angle andend_angle . Notably,end_angle can be smaller thanstart_angle , in which case the region passes over the 360/0 deg bound. This function is unit-independent (but all angles have to have the same unit), so degrees, radians, and arbitrary scale factors can be used.

template<typename T>
bool nebula::drivers::angle_is_between (
    T start_angle,
    T end_angle,
    T angle,
    bool start_inclusive=true,
    bool end_inclusive=true
)

function convert_point_xyziradt_to_point_xyzir

pcl::PointCloud< PointXYZIR >::Ptr nebula::drivers::convert_point_xyziradt_to_point_xyzir (
    const pcl::PointCloud< PointXYZIRADT >::ConstPtr & input_pointcloud
)

function convert_point_xyzircaedt_to_point_xyzir

pcl::PointCloud< PointXYZIR >::Ptr nebula::drivers::convert_point_xyzircaedt_to_point_xyzir (
    const pcl::PointCloud< PointXYZIRCAEDT >::ConstPtr & input_pointcloud
)

function convert_point_xyzircaedt_to_point_xyziradt

pcl::PointCloud< PointXYZIRADT >::Ptr nebula::drivers::convert_point_xyzircaedt_to_point_xyziradt (
    const pcl::PointCloud< PointXYZIRCAEDT >::ConstPtr & input_pointcloud,
    double stamp
)

function crc

Given a memory range, calculates the CRC over its bytes.

template<typename crc_type, typename T, typename U>
crc_type::value_type nebula::drivers::crc (
    const T * begin,
    const U * end
)

Both begin and end can be pointers to arbitrary types. They will be cast to void *.

A common example looks like:

 ++
struct MyStruct {
  int a;
  float b;
  uint32_t crc;

  bool is_crc_valid() const {
    return crc<crc8h2f_t>(&a, &crc) == crc;
  }
};

Template parameters:

crc_type The type of CRC algorithm to use. Has to be a boost::crc_optimal type.

Parameters:

begin The beginning of the memory range
end One (byte) past the end of the memory range

Returns:

crc_type::value_type The computed CRC

function normalize_angle

Normalizes an angle to the interval [0; max_angle]. This function is unit-independent. max_angle is 360 for degrees, 2 * M_PI for radians, and the corresponding scaled value for scaled units such as centi-degrees (36000).

template<typename T>
T nebula::drivers::normalize_angle (
    T angle,
    T max_angle
)

function operator<<

Convert ReturnType enum to string (Overloading the << operator)

inline std::ostream & nebula::drivers::operator<< (
    std::ostream & os,
    nebula::drivers::ReturnType const & arg
)

Parameters:

os
arg

Returns:

stream

function operator<<

Convert ReturnMode enum to string (Overloading the << operator)

inline std::ostream & nebula::drivers::operator<< (
    std::ostream & os,
    nebula::drivers::ReturnMode const & arg
)

Parameters:

os
arg

Returns:

stream

function operator<<

Convert SensorModel enum to string (Overloading the << operator)

inline std::ostream & nebula::drivers::operator<< (
    std::ostream & os,
    nebula::drivers::SensorModel const & arg
)

Parameters:

os
arg

Returns:

stream

function operator<<

Convert SensorConfigurationBase to string (Overloading the << operator)

inline std::ostream & nebula::drivers::operator<< (
    std::ostream & os,
    SensorConfigurationBase const & arg
)

Parameters:

os
arg

Returns:

stream

function operator<<

Convert EthernetSensorConfigurationBase to string (Overloading the << operator)

inline std::ostream & nebula::drivers::operator<< (
    std::ostream & os,
    EthernetSensorConfigurationBase const & arg
)

Parameters:

os
arg

Returns:

stream

function operator<<

Convert CANSensorConfigurationBase to string (Overloading the << operator)

inline std::ostream & nebula::drivers::operator<< (
    std::ostream & os,
    CANSensorConfigurationBase const & arg
)

Parameters:

os
arg

Returns:

stream

function operator<<

Convert LidarConfigurationBase to string (Overloading the << operator)

inline std::ostream & nebula::drivers::operator<< (
    std::ostream & os,
    nebula::drivers::LidarConfigurationBase const & arg
)

Parameters:

os
arg

Returns:

stream

function return_mode_from_string

Convert return mode name to ReturnMode enum.

inline ReturnMode nebula::drivers::return_mode_from_string (
    const std::string & return_mode
)

Parameters:

return_mode Return mode name (Upper and lower case letters must match)

Returns:

Corresponding ReturnMode

function sensor_model_from_string

Convert sensor name to SensorModel enum (Upper and lower case letters must match)

inline SensorModel nebula::drivers::sensor_model_from_string (
    const std::string & sensor_model
)

Parameters:

sensor_model Sensor name (Upper and lower case letters must match)

Returns:

Corresponding SensorModel

function sensor_model_to_string

inline std::string nebula::drivers::sensor_model_to_string (
    const SensorModel & sensor_model
)

Public Static Functions Documentation

function deg2rad

Converts degrees to radians.

static inline float nebula::drivers::deg2rad (
    double degrees
)

Parameters:

radians

Returns:

degrees

function rad2deg

Converts radians to degrees.

static inline float nebula::drivers::rad2deg (
    double radians
)

Parameters:

radians

Returns:

degrees

function rpm2hz

Converts RPM to Hertz.

static inline double nebula::drivers::rpm2hz (
    double rpm
)

Parameters:

rpm

Returns:

Hertz

The documentation for this class was generated from the following file src/nebula_core/nebula_core_common/include/nebula_core_common/loggers/console_logger.hpp