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  
} 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 {
  kStatusSuccess = 0,        
  kStatusFailure = 1,        
  kStatusNotConnected = 2,   
  kStatusNotSupported = 3,   
  kStatusTimeout = 4,        
  kStatusNotEnoughMemory = 5 
} ResponseStatus;

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

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

#pragma pack(1)

#define LIVOX_SDK_MAJOR_VERSION       1
#define LIVOX_SDK_MINOR_VERSION       1
#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 {
  float x;              
  float y;              
  float z;              
  uint8_t reflectivity; 
} LivoxPoint;

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 status_code; 
  uint32_t progress;   
} StatusUnion;

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

typedef struct {
  char broadcast_code[kBroadcastCodeSize]; 
  uint8_t dev_type;                        
  uint16_t reserved;                           
} 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]; 
  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;  
} HandshakeRequest;

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

typedef struct {
  uint32_t error_code; 
} ErrorMessage;

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; 
} GetDeviceIPModeResponse;

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

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

#pragma pack()

#endif  // LIVOX_DEF_H_