Namespace nebula::drivers

Namespace List > nebula > drivers

Namespaces

Type	Name
namespace	continental_ars548
namespace	continental_srr520
namespace	hesai_packet
namespace	robosense_packet
namespace	vlp16
namespace	vlp32
namespace	vls128

Classes

Type	Name
class	AngleCorrector <typename CorrectionDataT> Handles angle correction for given azimuth/channel combinations, as well as trigonometry lookup tables.
class	AngleCorrectorCalibrationBased <ChannelN, AngleUnit>
class	AngleCorrectorCorrectionBased <ChannelN, AngleUnit>
class	BpearlV3
class	BpearlV4
class	ContinentalPacketsDecoder Base class for Continental Radar decoder.
struct	CorrectedAngleData
class	Helios
class	HesaiDecoder <typename SensorT>
class	HesaiDriver Hesai driver.
class	HesaiScanDecoder Base class for Hesai LiDAR decoder.
class	HesaiSensor <typename PacketT, AngleCorrection> Base class for all sensor definitions.
class	NebulaDriverBase Base class for each sensor driver.
class	Pandar128E3X
class	Pandar128E4X
class	Pandar40
class	Pandar64
class	PandarAT128
class	PandarQT128
class	PandarQT64
class	PandarXT32
class	PandarXT32M
class	RobosenseDecoder <typename SensorT>
class	RobosenseDriver Robosense driver.
class	RobosenseInfoDecoder <typename SensorT>
class	RobosenseInfoDecoderBase
class	RobosenseInfoDriver Robosense driver.
class	RobosenseScanDecoder Base class for Robosense LiDAR decoder.
class	RobosenseSensor <typename PacketT, typename InfoPacketT> Base class for all sensor definitions.
class	VelodyneDriver Velodyne driver.
class	VelodyneScanDecoder Base class for Velodyne LiDAR decoder.
struct	raw_block Raw Velodyne data block.
struct	raw_packet Raw Velodyne packet.

Public Types

Type	Name
enum	AngleCorrectionType
enum	RETURN_TYPE Velodyne echo types.
union	two_bytes
typedef struct nebula::drivers::raw_block	raw_block_t Raw Velodyne data block.
typedef struct nebula::drivers::raw_packet	raw_packet_t Raw Velodyne packet.

Public Static Attributes

Type	Name
const int	BLOCKS_PER_PACKET = = 12
const int	BLOCK_DATA_SIZE = = (SCANS_PER_BLOCK * RAW_SCAN_SIZE)
const uint32_t	DEGREE_SUBDIVISIONS = = 100
const uint16_t	LOWER_BANK = = 0xddff
const size_t	OFFSET_FIRST_AZIMUTH = = 2
const size_t	OFFSET_LAST_AZIMUTH = = 1102
const int	PACKET_SIZE = = 1206
const int	PACKET_STATUS_SIZE = = 4
const int	RAW_SCAN_SIZE = = 3
const uint16_t	RETURN_MODE_DUAL = = 57
const size_t	RETURN_MODE_INDEX = = 1204
const uint16_t	RETURN_MODE_LAST = = 56
const uint16_t	RETURN_MODE_STRONGEST = = 55
const uint16_t	ROTATION_MAX_UNITS = = 36000u
const double	ROTATION_RESOLUTION = = 0.01
const int	SCANS_PER_BLOCK = = 32
const int	SCANS_PER_PACKET = = (SCANS_PER_BLOCK * BLOCKS_PER_PACKET)
const int	SIZE_BLOCK = = 100
const uint16_t	UPPER_BANK = = 0xeeff
const float	VLP128_DISTANCE_RESOLUTION = = 0.004f
const float	VLP16_BLOCK_DURATION = = 110.592f
const float	VLP16_DSR_TOFFSET = = 2.304f
const int	VLP16_FIRINGS_PER_BLOCK = = 2
const float	VLP16_FIRING_TOFFSET = = 55.296f
const int	VLP16_SCANS_PER_FIRING = = 16
const float	VLP32_CHANNEL_DURATION = = 2.304f
const float	VLP32_SEQ_DURATION = = 55.296f
const uint16_t	VLS128_BANK_1 = = 0xeeff
const uint16_t	VLS128_BANK_2 = = 0xddff
const uint16_t	VLS128_BANK_3 = = 0xccff
const uint16_t	VLS128_BANK_4 = = 0xbbff
const float	VLS128_CHANNEL_DURATION = =
2.665f
const float	VLS128_SEQ_DURATION = =
53.3f

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 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.

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).

Public Types Documentation

enum AngleCorrectionType

enum nebula::drivers::AngleCorrectionType {
    CALIBRATION,
    CORRECTION
};

enum RETURN_TYPE

enum nebula::drivers::RETURN_TYPE {
    INVALID = 0,
    SINGLE_STRONGEST = 1,
    SINGLE_LAST = 2,
    DUAL_STRONGEST_FIRST = 3,
    DUAL_STRONGEST_LAST = 4,
    DUAL_WEAK_FIRST = 5,
    DUAL_WEAK_LAST = 6,
    DUAL_ONLY = 7
};

union two_bytes

used for unpacking the first two data bytes in a block

They are packed into the actual data stream misaligned. I doubt this works on big endian machines.

typedef raw_block_t

Raw Velodyne data block.

typedef struct nebula::drivers::raw_block nebula::drivers::raw_block_t;

Each block contains data from either the upper or lower laser bank. The device returns three times as many upper bank blocks.

use stdint.h types, so things work with both 64 and 32-bit machines

typedef raw_packet_t

Raw Velodyne packet.

typedef struct nebula::drivers::raw_packet nebula::drivers::raw_packet_t;

revolution is described in the device manual as incrementing (mod 65536) for each physical turn of the device. Our device seems to alternate between two different values every third packet. One value increases, the other decreases.

Todo

figure out if revolution is only present for one of the two types of status fields

status has either a temperature encoding or the microcode level

Public Static Attributes Documentation

variable BLOCKS_PER_PACKET

const int nebula::drivers::BLOCKS_PER_PACKET;

variable BLOCK_DATA_SIZE

const int nebula::drivers::BLOCK_DATA_SIZE;

variable DEGREE_SUBDIVISIONS

const uint32_t nebula::drivers::DEGREE_SUBDIVISIONS;

variable LOWER_BANK

const uint16_t nebula::drivers::LOWER_BANK;

variable OFFSET_FIRST_AZIMUTH

const size_t nebula::drivers::OFFSET_FIRST_AZIMUTH;

variable OFFSET_LAST_AZIMUTH

const size_t nebula::drivers::OFFSET_LAST_AZIMUTH;

variable PACKET_SIZE

const int nebula::drivers::PACKET_SIZE;

variable PACKET_STATUS_SIZE

const int nebula::drivers::PACKET_STATUS_SIZE;

variable RAW_SCAN_SIZE

const int nebula::drivers::RAW_SCAN_SIZE;

variable RETURN_MODE_DUAL

const uint16_t nebula::drivers::RETURN_MODE_DUAL;

variable RETURN_MODE_INDEX

const size_t nebula::drivers::RETURN_MODE_INDEX;

variable RETURN_MODE_LAST

const uint16_t nebula::drivers::RETURN_MODE_LAST;

variable RETURN_MODE_STRONGEST

const uint16_t nebula::drivers::RETURN_MODE_STRONGEST;

Return Modes

variable ROTATION_MAX_UNITS

const uint16_t nebula::drivers::ROTATION_MAX_UNITS;

variable ROTATION_RESOLUTION

const double nebula::drivers::ROTATION_RESOLUTION;

variable SCANS_PER_BLOCK

const int nebula::drivers::SCANS_PER_BLOCK;

variable SCANS_PER_PACKET

const int nebula::drivers::SCANS_PER_PACKET;

variable SIZE_BLOCK

const int nebula::drivers::SIZE_BLOCK;

Raw Velodyne packet constants and structures.

variable UPPER_BANK

const uint16_t nebula::drivers::UPPER_BANK;

Todo

make this work for both big and little-endian machines

variable VLP128_DISTANCE_RESOLUTION

const float nebula::drivers::VLP128_DISTANCE_RESOLUTION;

Special Definitions for VLS128 support

variable VLP16_BLOCK_DURATION

const float nebula::drivers::VLP16_BLOCK_DURATION;

variable VLP16_DSR_TOFFSET

const float nebula::drivers::VLP16_DSR_TOFFSET;

variable VLP16_FIRINGS_PER_BLOCK

const int nebula::drivers::VLP16_FIRINGS_PER_BLOCK;

Special Defines for VLP16 support

variable VLP16_FIRING_TOFFSET

const float nebula::drivers::VLP16_FIRING_TOFFSET;

variable VLP16_SCANS_PER_FIRING

const int nebula::drivers::VLP16_SCANS_PER_FIRING;

variable VLP32_CHANNEL_DURATION

const float nebula::drivers::VLP32_CHANNEL_DURATION;

Special Defines for VLP32 support

variable VLP32_SEQ_DURATION

const float nebula::drivers::VLP32_SEQ_DURATION;

variable VLS128_BANK_1

const uint16_t nebula::drivers::VLS128_BANK_1;

Special Definitions for VLS128 support

variable VLS128_BANK_2

const uint16_t nebula::drivers::VLS128_BANK_2;

variable VLS128_BANK_3

const uint16_t nebula::drivers::VLS128_BANK_3;

variable VLS128_BANK_4

const uint16_t nebula::drivers::VLS128_BANK_4;

variable VLS128_CHANNEL_DURATION

const float nebula::drivers::VLS128_CHANNEL_DURATION;

variable VLS128_SEQ_DURATION

const float nebula::drivers::VLS128_SEQ_DURATION;

Public Functions Documentation

function angle_is_between

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 normalize_angle

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

The documentation for this class was generated from the following file nebula_decoders/include/nebula_decoders/nebula_decoders_common/angles.hpp