livox_def.h

Go to the documentation of this file.

//
// The MIT License (MIT)
//
// Copyright (c) 2019 Livox. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//

#ifndef LIVOX_DEF_H_
#define LIVOX_DEF_H_

#include <stdint.h>

#define kMaxLidarCount 32

typedef enum {
  kDeviceTypeHub = 0,          
  kDeviceTypeLidarMid40 = 1,   
  kDeviceTypeLidarTele = 2,    
  kDeviceTypeLidarHorizon = 3,  
  kDeviceTypeLidarMid70 = 6,    
  kDeviceTypeLidarAvia = 7     
} DeviceType;

typedef enum {
  kLidarStateInit = 0,        
  kLidarStateNormal = 1,      
  kLidarStatePowerSaving = 2, 
  kLidarStateStandBy = 3,     
  kLidarStateError = 4,       
  kLidarStateUnknown = 5      
} LidarState;

typedef enum {
  kLidarModeNormal = 1,      
  kLidarModePowerSaving = 2, 
  kLidarModeStandby = 3      
} LidarMode;

typedef enum {
  kLidarFeatureNone = 0,   
  kLidarFeatureRainFog = 1 
} LidarFeature;

typedef enum {
  kLidarDynamicIpMode = 0,   
  kLidarStaticIpMode = 1     
} LidarIpMode;

typedef enum {
  kNoneRepetitiveScanPattern = 0,  
  kRepetitiveScanPattern = 1,      
} LidarScanPattern;

typedef enum {
  kStatusSendFailed = -9,           
  kStatusHandlerImplNotExist = -8,  
  kStatusInvalidHandle = -7,        
  kStatusChannelNotExist = -6,      
  kStatusNotEnoughMemory = -5,      
  kStatusTimeout = -4,              
  kStatusNotSupported = -3,         
  kStatusNotConnected = -2,         
  kStatusFailure = -1,              
  kStatusSuccess = 0                
} LivoxStatus;

typedef int32_t livox_status;

typedef enum {
  kEventConnect = 0,              
  kEventDisconnect = 1,           
  kEventStateChange = 2,          
  kEventHubConnectionChange = 3   
} DeviceEvent;

typedef enum {
  kTimestampTypeNoSync = 0, 
  kTimestampTypePtp = 1,    
  kTimestampTypeRsvd = 2,   
  kTimestampTypePpsGps = 3, 
  kTimestampTypePps = 4,    
  kTimestampTypeUnknown = 5 
} TimestampType;

typedef enum {
  kCartesian,               
  kSpherical,               
  kExtendCartesian,         
  kExtendSpherical,         
  kDualExtendCartesian,     
  kDualExtendSpherical,     
  kImu,                     
  kTripleExtendCartesian,   
  kTripleExtendSpherical,   
  kMaxPointDataType         
} PointDataType;

typedef enum {
  kFirstReturn,             
  kStrongestReturn,         
  kDualReturn,              
  kTripleReturn,            
} PointCloudReturnMode;

typedef enum {
  kImuFreq0Hz,              
  kImuFreq200Hz,            
} ImuFreq;

#pragma pack(1)

#define LIVOX_SDK_MAJOR_VERSION       2
#define LIVOX_SDK_MINOR_VERSION       2
#define LIVOX_SDK_PATCH_VERSION       0

#define kBroadcastCodeSize 16

typedef struct {
  int major;      
  int minor;      
  int patch;      
} LivoxSdkVersion;

typedef struct {
  int32_t x;            
  int32_t y;            
  int32_t z;            
  uint8_t reflectivity; 
} LivoxRawPoint;

typedef struct {
  uint32_t depth;       
  uint16_t theta;       
  uint16_t phi;         
  uint8_t reflectivity; 
} LivoxSpherPoint;

typedef struct {
  float x;              
  float y;              
  float z;              
  uint8_t reflectivity; 
} LivoxPoint;

typedef struct {
  int32_t x;            
  int32_t y;            
  int32_t z;            
  uint8_t reflectivity; 
  uint8_t tag;          
} LivoxExtendRawPoint;

typedef struct {
  uint32_t depth;       
  uint16_t theta;       
  uint16_t phi;         
  uint8_t reflectivity; 
  uint8_t tag;          
} LivoxExtendSpherPoint;

typedef struct {
  int32_t x1;            
  int32_t y1;            
  int32_t z1;            
  uint8_t reflectivity1; 
  uint8_t tag1;          
  int32_t x2;            
  int32_t y2;            
  int32_t z2;            
  uint8_t reflectivity2; 
  uint8_t tag2;          
} LivoxDualExtendRawPoint;

typedef struct {
  uint16_t theta;        
  uint16_t phi;          
  uint32_t depth1;       
  uint8_t reflectivity1; 
  uint8_t tag1;          
  uint32_t depth2;       
  uint8_t reflectivity2; 
  uint8_t tag2;          
} LivoxDualExtendSpherPoint;

typedef struct {
  int32_t x1;            
  int32_t y1;            
  int32_t z1;            
  uint8_t reflectivity1; 
  uint8_t tag1;          
  int32_t x2;            
  int32_t y2;            
  int32_t z2;            
  uint8_t reflectivity2; 
  uint8_t tag2;          
  int32_t x3;            
  int32_t y3;            
  int32_t z3;            
  uint8_t reflectivity3; 
  uint8_t tag3;          
} LivoxTripleExtendRawPoint;

typedef struct {
  uint16_t theta;        
  uint16_t phi;          
  uint32_t depth1;       
  uint8_t reflectivity1; 
  uint8_t tag1;          
  uint32_t depth2;       
  uint8_t reflectivity2; 
  uint8_t tag2;          
  uint32_t depth3;       
  uint8_t reflectivity3; 
  uint8_t tag3;          
} LivoxTripleExtendSpherPoint;

typedef struct {
  float gyro_x;        
  float gyro_y;        
  float gyro_z;        
  float acc_x;         
  float acc_y;         
  float acc_z;         
} LivoxImuPoint;

typedef struct {
  uint32_t temp_status : 2;      
  uint32_t volt_status : 2;      
  uint32_t motor_status : 2;     
  uint32_t dirty_warn : 2;       
  uint32_t firmware_err : 1;     
  uint32_t pps_status : 1;       
  uint32_t device_status : 1;    
  uint32_t fan_status : 1;       
  uint32_t self_heating : 1;     
  uint32_t ptp_status : 1;       
  uint32_t time_sync_status : 3;
  uint32_t rsvd : 13;            
  uint32_t system_status : 2;    
} LidarErrorCode;

typedef struct {
  uint32_t sync_status : 2;
  uint32_t temp_status : 2;        
  uint32_t lidar_status : 1;       
  uint32_t lidar_link_status : 1;  
  uint32_t firmware_err : 1;       
  uint32_t rsvd : 23;              
  uint32_t system_status : 2;      
} HubErrorCode;

typedef union {
  uint32_t error_code;                
  LidarErrorCode lidar_error_code;    
  HubErrorCode hub_error_code;        
} ErrorMessage;

typedef struct {
  uint8_t version;              
  uint8_t slot;                 
  uint8_t id;                   
  uint8_t rsvd;                 
  uint32_t err_code;      
  uint8_t timestamp_type;       
  uint8_t data_type;
  uint8_t timestamp[8];         
  uint8_t data[1];              
} LivoxEthPacket;

typedef union {
  uint32_t progress;    
  ErrorMessage status_code; 
} StatusUnion;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t handle;                          
  uint8_t slot;                            
  uint8_t id;                              
  uint8_t type;                            
  uint16_t data_port;                      
  uint16_t cmd_port;                       
  uint16_t sensor_port;                    
  char ip[16];                             
  LidarState state;                        
  LidarFeature feature;                    
  StatusUnion status;                      
  uint8_t firmware_version[4];             
} DeviceInfo;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t dev_type;                        
  uint16_t reserved;                       
  char ip[16];                             
} BroadcastDeviceInfo;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t dev_type;                        
  uint8_t version[4];                      
  uint8_t slot;                            
  uint8_t id;                              
} ConnectedLidarInfo;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t state;                           
} LidarModeRequestItem;

typedef struct {
  uint8_t ret_code;                        
  char broadcast_code[kBroadcastCodeSize]; 
} ReturnCode;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
} DeviceBroadcastCode;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t feature;                         
} RainFogSuppressRequestItem;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t state;                           
} FanControlRequestItem;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
} GetFanStateRequestItem;

typedef struct {
  uint8_t ret_code;                        
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t state;                           
} GetFanStateResponseItem;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t mode;                            
} SetPointCloudReturnModeRequestItem;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
} GetPointCloudReturnModeRequestItem;

typedef struct {
  uint8_t ret_code;                        
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t mode;                            
} GetPointCloudReturnModeResponseItem;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t freq;                            
} SetImuPushFrequencyRequestItem;


typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
} GetImuPushFrequencyRequestItem;

typedef struct {
  uint8_t ret_code;                        
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t freq;                            
} GetImuPushFrequencyResponseItem;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  float roll;                              
  float pitch;                             
  float yaw;                               
  int32_t x;                               
  int32_t y;                               
  int32_t z;                               
} ExtrinsicParameterRequestItem;

typedef struct {
  uint8_t ret_code;                        
  char broadcast_code[kBroadcastCodeSize]; 
  float roll;                              
  float pitch;                             
  float yaw;                               
  int32_t x;                               
  int32_t y;                               
  int32_t z;                               
} ExtrinsicParameterResponseItem;

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t state;                           
  uint8_t feature;                         
  StatusUnion error_union;                 
} LidarStateItem;

typedef struct {
  uint32_t ip_addr;     
  uint16_t data_port;   
  uint16_t cmd_port;    
  uint16_t sensor_port; 
} HandshakeRequest;

typedef struct {
  uint8_t ret_code;            
  uint8_t firmware_version[4]; 
} DeviceInformationResponse;

typedef struct {
  uint8_t ip_mode;  
  uint32_t ip_addr; 
} SetDeviceIPModeRequest;

typedef struct {
  uint8_t ret_code;  
  uint8_t ip_mode;   
  uint32_t ip_addr;  
  uint32_t net_mask; 
  uint32_t gw_addr;  
} GetDeviceIpModeResponse;

typedef struct {
  uint32_t ip_addr;  
  uint32_t net_mask; 
  uint32_t gw_addr;  
} SetStaticDeviceIpModeRequest;

typedef struct {
  uint8_t ret_code;        
  uint8_t state;           
  uint8_t feature;         
  StatusUnion error_union; 
} HeartbeatResponse;

typedef enum {
  kKeyNoError = 0,                  
  kKeyNotSupported = 1,             
  kKeyExecFailed = 2,               
  kKeyNotSupportedWritingState = 3, 
  kKeyValueError = 4,               
  kKeyValueLengthError = 5,         
  kKeyNoEnoughMemory = 6,           
  kKeyLengthError = 7,              
} KeyErrorCode;

typedef struct {
  uint8_t ret_code;              
  uint16_t error_param_key;      
  uint8_t error_code;            
} DeviceParameterResponse;

typedef enum {
  kKeyDefault = 0,              
  kKeyHighSensetivity = 1,      
  kKeyScanPattern =  2,         
  kKeySlotNum = 3,              
} DeviceParamKeyName;

typedef struct {
  uint16_t key;                /*< Key, refer to \ref DeviceParamKeyName. */
  uint16_t length;             /*< Length of value */
  uint8_t value[1];            /*< Value */
} KeyValueParam;

typedef struct {
  DeviceParameterResponse rsp;     /*< Return code. */
  KeyValueParam kv;                /*< Key and value of device's parameters. */
} GetDeviceParameterResponse;

typedef struct {
  uint8_t param_num;           /*< Number of key. */
  uint16_t key[1];             /*< Key, refer to \ref DeviceParamKeyName. */
} GetDeviceParameterRequest;

typedef struct {
  uint8_t flag;                /*< 0: for resetting all keys, 1: for resetting part of keys. */
  uint8_t key_num;             /*< number of keys to reset. */
  uint16_t key[1];             /*< Keys to reset, refer to \ref DeviceParamKeyName. */
} ResetDeviceParameterRequest;

typedef struct {
  float roll;  
  float pitch; 
  float yaw;   
  int32_t x;   
  int32_t y;   
  int32_t z;   
} LidarSetExtrinsicParameterRequest;

typedef struct {
  uint8_t ret_code;
  float roll;  
  float pitch; 
  float yaw;   
  int32_t x;   
  int32_t y;   
  int32_t z;   
} LidarGetExtrinsicParameterResponse;

typedef struct {
  uint8_t ret_code;     
  uint8_t state;        
} LidarGetFanStateResponse;

typedef struct {
  uint8_t ret_code;    
  uint8_t mode;        
} LidarGetPointCloudReturnModeResponse;


typedef struct {
  uint8_t ret_code;            
  uint8_t freq;                
} LidarGetImuPushFrequencyResponse;

typedef struct {
  uint8_t year;
  uint8_t month;
  uint8_t day;
  uint8_t hour;
  uint32_t mircrosecond;
} LidarSetUtcSyncTimeRequest;

typedef struct {
  uint8_t ret_code;                       
  uint8_t count;                          
  ConnectedLidarInfo device_info_list[1]; 
} HubQueryLidarInformationResponse;

typedef struct {
  uint8_t count;                       
  LidarModeRequestItem config_list[1]; 
} HubSetModeRequest;

typedef struct {
  uint8_t ret_code;             
  uint8_t count;                
  ReturnCode ret_state_list[1]; 
} HubSetModeResponse;

typedef struct {
  uint8_t slot;  
  uint8_t state; 
} HubControlSlotPowerRequest;

typedef struct {
  uint8_t count;                 
  ExtrinsicParameterRequestItem parameter_list[1]; 
} HubSetExtrinsicParameterRequest;

typedef struct {
  uint8_t ret_code;            
  uint8_t count;               
  ReturnCode ret_code_list[1]; 
} HubSetExtrinsicParameterResponse;

typedef struct {
  uint8_t count;                    
  DeviceBroadcastCode code_list[1]; 
} HubGetExtrinsicParameterRequest;

typedef struct {
  uint8_t ret_code;        
  uint8_t count;           
  ExtrinsicParameterResponseItem parameter_list[1]; 
} HubGetExtrinsicParameterResponse;

typedef struct {
  uint8_t ret_code;             
  uint8_t count;                
  LidarStateItem state_list[1]; 
} HubQueryLidarStatusResponse;

typedef struct {
  uint8_t count;                                
  RainFogSuppressRequestItem lidar_cfg_list[1]; 
} HubRainFogSuppressRequest;

typedef struct {
  uint8_t ret_code;             
  uint8_t count;                
  ReturnCode ret_state_list[1]; 
} HubRainFogSuppressResponse;

typedef struct {
  uint8_t ret_code;             
  uint16_t slot_power_state;    
} HubQuerySlotPowerStatusResponse;

typedef struct {
  uint8_t count;                
  FanControlRequestItem lidar_cfg_list[1]; 
} HubFanControlRequest;

typedef struct {
  uint8_t ret_code;             
  uint8_t count;                
  ReturnCode return_list[1];    
} HubFanControlResponse;

typedef struct {
  uint8_t count;                             
  GetFanStateRequestItem lidar_cfg_list[1];  
} HubGetFanStateRequest;

typedef struct {
  uint8_t ret_code;                         
  uint8_t count;                            
  GetFanStateResponseItem return_list[1];   
} HubGetFanStateResponse;

typedef struct {
  uint8_t count;         
  SetPointCloudReturnModeRequestItem lidar_cfg_list[1]; 
} HubSetPointCloudReturnModeRequest;

typedef struct {
  uint8_t ret_code;             
  uint8_t count;                
  ReturnCode return_list[1];    
} HubSetPointCloudReturnModeResponse;

typedef struct {
  uint8_t count;                
  GetPointCloudReturnModeRequestItem lidar_cfg_list[1]; 
} HubGetPointCloudReturnModeRequest;

typedef struct {
  uint8_t ret_code;               
  uint8_t count;                  
  GetPointCloudReturnModeResponseItem return_list[1];  
} HubGetPointCloudReturnModeResponse;

typedef struct {
  uint8_t count;                 
  SetImuPushFrequencyRequestItem lidar_cfg_list[1]; 
} HubSetImuPushFrequencyRequest;

typedef struct {
  uint8_t ret_code;               
  uint8_t count;                  
  ReturnCode return_list[1];      
} HubSetImuPushFrequencyResponse;

typedef struct {
  uint8_t count;                 
  GetImuPushFrequencyRequestItem lidar_cfg_list[1];  
} HubGetImuPushFrequencyRequest;

typedef struct {
  uint8_t ret_code;              
  uint8_t count;                 
  GetImuPushFrequencyResponseItem return_list[1];    
} HubGetImuPushFrequencyResponse;

#pragma pack()

#endif  // LIVOX_DEF_H_