From 31bff6868bd18bd7aa12b951bb21d3e5df5b1fca Mon Sep 17 00:00:00 2001 From: Oliveiratang Date: Fri, 11 Jul 2025 19:42:45 +0800 Subject: [PATCH] support Odin 1. support Ubuntu 18.04,Ubuntu 20.04,Ubuntu22.04. support for ROS1 and ROS2. --- CMakeLists.txt | 297 +++++++++++++++++ LICENSE | 2 +- README.md | 235 +++++++++++++ config/control_command.yaml | 7 + include/host_sdk_sample.h | 549 +++++++++++++++++++++++++++++++ include/lidar_api.h | 216 ++++++++++++ include/lidar_api_type.h | 131 ++++++++ include/yaml_parser.h | 38 +++ launch_ROS1/odin1_ros1.launch | 12 + launch_ROS2/odin1_ros2.launch.py | 38 +++ lib/liblydHostApi_amd.a | Bin 0 -> 253790 bytes lib/liblydHostApi_arm.a | Bin 0 -> 268474 bytes package_ros1.xml | 29 ++ package_ros2.xml | 22 ++ script/build_ros.sh | 128 +++++++ script/build_ros2.sh | 158 +++++++++ src/host_sdk_sample.cpp | 330 +++++++++++++++++++ src/yaml_parser.cpp | 83 +++++ 18 files changed, 2274 insertions(+), 1 deletion(-) create mode 100644 CMakeLists.txt create mode 100644 README.md create mode 100644 config/control_command.yaml create mode 100644 include/host_sdk_sample.h create mode 100644 include/lidar_api.h create mode 100644 include/lidar_api_type.h create mode 100644 include/yaml_parser.h create mode 100644 launch_ROS1/odin1_ros1.launch create mode 100644 launch_ROS2/odin1_ros2.launch.py create mode 100644 lib/liblydHostApi_amd.a create mode 100644 lib/liblydHostApi_arm.a create mode 100644 package_ros1.xml create mode 100644 package_ros2.xml create mode 100644 script/build_ros.sh create mode 100644 script/build_ros2.sh create mode 100644 src/host_sdk_sample.cpp create mode 100644 src/yaml_parser.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..e9485e7 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,297 @@ +cmake_minimum_required(VERSION 3.5) +project(odin_ros_driver) + + +if(DEFINED BUILD_SYSTEM) + set(ROS_VERSION ${BUILD_SYSTEM}) + message(STATUS "使用命令行指定的构建系统: ${ROS_VERSION}") +elseif(DEFINED ENV{ROS_DISTRO}) + if("$ENV{ROS_DISTRO}" MATCHES "foxy|galactic|humble|iron|rolling") + set(ROS_VERSION "ROS2") + else() + set(ROS_VERSION "ROS1") + endif() +elseif(DEFINED ENV{ROS_VERSION}) + if("$ENV{ROS_VERSION}" EQUAL "2") + set(ROS_VERSION "ROS2") + else() + set(ROS_VERSION "ROS1") + endif() +else() + # 尝试自动检测 + if(COMMAND catkin_package) + set(ROS_VERSION "ROS1") + elseif(COMMAND ament_package) + set(ROS_VERSION "ROS2") + else() + # 默认使用ROS2 + set(ROS_VERSION "ROS2") + message(WARNING "无法确定ROS版本，默认使用ROS2") + endif() +endif() + +# 检测 ROS 版本后添加编译宏 +if(ROS_VERSION STREQUAL "ROS2") + add_definitions(-DROS2) + message(STATUS "定义 ROS2 宏") +else() + add_definitions(-DROS1) + message(STATUS "定义 ROS1 宏") +endif() + +message(STATUS "构建系统: ${ROS_VERSION}") + +# 平台检测 +execute_process( + COMMAND uname -m + OUTPUT_VARIABLE ARCH + OUTPUT_STRIP_TRAILING_WHITESPACE +) + +if(ARCH STREQUAL "x86_64") + set(TARGET_PLATFORM "x86") + message(STATUS "检测到 x86_64 架构") +elseif(ARCH MATCHES "arm|aarch64") + set(TARGET_PLATFORM "arm") + message(STATUS "检测到 ARM 架构: ${ARCH}") +else() + message(WARNING "不支持的架构: ${ARCH}. 使用默认设置") + set(TARGET_PLATFORM "unknown") +endif() + +# 设置库路径 +set(LIB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/lib") +message(STATUS "库目录: ${LIB_DIR}") + +# 根据平台设置库名称 +if(TARGET_PLATFORM STREQUAL "arm") + set(LYD_HOST_API_LIB_NAME "lydHostApi_arm") +else() + set(LYD_HOST_API_LIB_NAME "lydHostApi_amd") +endif() + +# 查找预编译的 lydHostApi 库 +find_library(LYD_HOST_API_LIB + NAMES + ${LYD_HOST_API_LIB_NAME} + lib${LYD_HOST_API_LIB_NAME}.a + lib${LYD_HOST_API_LIB_NAME}.so + PATHS ${LIB_DIR} + NO_DEFAULT_PATH +) + +if(LYD_HOST_API_LIB) + message(STATUS "找到 lydHostApi 库: ${LYD_HOST_API_LIB}") +else() + file(GLOB LIB_FILES "${LIB_DIR}/lib${LYD_HOST_API_LIB_NAME}.*") + if(LIB_FILES) + message(STATUS "找到库文件: ${LIB_FILES}") + set(LYD_HOST_API_LIB ${LIB_FILES}) + else() + message(FATAL_ERROR "在 ${LIB_DIR} 中找不到预编译的 lydHostApi 库") + endif() +endif() + +# 设置公共编译选项 +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# 公共依赖查找 +find_package(PkgConfig REQUIRED) +find_package(OpenCV REQUIRED COMPONENTS core imgproc highgui) +find_package(Eigen3 REQUIRED) +find_package(yaml-cpp REQUIRED) +find_package(OpenSSL REQUIRED) +pkg_check_modules(LIBUSB REQUIRED libusb-1.0) + +# 共享包含目录 +include_directories( + include + ${EIGEN3_INCLUDE_DIRS} + ${OpenCV_INCLUDE_DIRS} + ${yaml-cpp_INCLUDE_DIR} + ${LIBUSB_INCLUDE_DIRS} + ${CMAKE_CURRENT_SOURCE_DIR}/include +) + +# 共享链接库列表 +set(COMMON_LIBS + ${OpenCV_LIBS} + ${yaml-cpp_LIBRARIES} + ${OPENSSL_LIBRARIES} + ${LIBUSB_LIBRARIES} + pthread + rt + ${CMAKE_DL_LIBS} + ${LYD_HOST_API_LIB} +) + +# ===== ROS1 专属配置 ===== +if(ROS_VERSION STREQUAL "ROS1") + message(STATUS "配置为 ROS1 构建") + + find_package(catkin REQUIRED COMPONENTS + roscpp + std_msgs + sensor_msgs + nav_msgs + cv_bridge + image_transport + ) + + include_directories(${catkin_INCLUDE_DIRS}) + + catkin_package( + CATKIN_DEPENDS roscpp std_msgs sensor_msgs nav_msgs cv_bridge image_transport + INCLUDE_DIRS include + ) + + # 设置输出目录 + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CATKIN_DEVEL_PREFIX}/lib/${PROJECT_NAME}) + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CATKIN_DEVEL_PREFIX}/lib) + set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CATKIN_DEVEL_PREFIX}/lib) + + add_executable(host_sdk_sample + src/host_sdk_sample.cpp + src/yaml_parser.cpp + ) + target_link_libraries(host_sdk_sample + ${catkin_LIBRARIES} + ${COMMON_LIBS} + ${LYD_HOST_API_LIB} + ${LIBUSB_LIBRARIES} + yaml-cpp + ${OpenCV_LIBS} + pthread + usb-1.0 + ) + + # 安装规则 + install(TARGETS host_sdk_sample + RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} + ) + + install(DIRECTORY include/ + DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION} + FILES_MATCHING PATTERN "*.h" + ) + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/config") + install(DIRECTORY config/ + DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}/config + ) + endif() + +# ===== ROS2 配置 ===== +elseif(ROS_VERSION STREQUAL "ROS2") + message(STATUS "配置为 ROS2 构建") + + # 查找所有必要的ROS2包 + find_package(ament_cmake REQUIRED) + find_package(rclcpp REQUIRED) + find_package(std_msgs REQUIRED) + find_package(sensor_msgs REQUIRED) + find_package(nav_msgs REQUIRED) + find_package(cv_bridge REQUIRED) + find_package(image_transport REQUIRED) + + # 创建可执行文件 + add_executable(host_sdk_sample + src/host_sdk_sample.cpp + src/yaml_parser.cpp + ) + + # 链接库 + target_link_libraries(host_sdk_sample + ${catkin_LIBRARIES} + ${COMMON_LIBS} + yaml-cpp + usb-1.0 + ) + + # 添加ROS2依赖 + ament_target_dependencies(host_sdk_sample + rclcpp + std_msgs + sensor_msgs + nav_msgs + cv_bridge + image_transport + ) + + # 安装规则 - 确保所有安装目标在 ament_package() 之前定义 + # 安装可执行文件 + install(TARGETS host_sdk_sample + EXPORT export_${PROJECT_NAME} + ARCHIVE DESTINATION lib + LIBRARY DESTINATION lib + RUNTIME DESTINATION lib/${PROJECT_NAME} + ) + + # 安装 package.xml + install(FILES package.xml + DESTINATION share/${PROJECT_NAME} + ) + + # 安装头文件 + install(DIRECTORY include/ + DESTINATION include + ) + # 安装 launch_ROS2 目录 + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/launch_ROS2") + install(DIRECTORY launch_ROS2/ + DESTINATION share/${PROJECT_NAME}/launch + ) + message(STATUS "安装 launch_ROS2 目录到 share/${PROJECT_NAME}/launch") + else() + message(WARNING "未找到 launch_ROS2 目录") + endif() + # 安装配置文件 (如果存在) + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/config") + install(DIRECTORY config/ + DESTINATION share/${PROJECT_NAME}/config + ) + endif() + + # 安装启动文件 (如果存在) + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/launch") + install(DIRECTORY launch/ + DESTINATION share/${PROJECT_NAME}/launch + ) + endif() + ament_export_targets(export_${PROJECT_NAME}) + # 声明依赖 + ament_export_dependencies( + rclcpp + std_msgs + sensor_msgs + nav_msgs + cv_bridge + image_transport + ) + + # 可选的lint检查 + + # 完成包配置 - 必须在所有安装规则之后调用 + ament_package() + message(STATUS "安装目标已添加") + +else() + message(FATAL_ERROR "无效的 ROS_VERSION: ${ROS_VERSION}") +endif() + +# ARM平台特定的链接选项 +if(TARGET_PLATFORM STREQUAL "arm") + set_target_properties(host_sdk_sample PROPERTIES + LINK_FLAGS "-Wl,--no-as-needed -Wl,--rpath=${LIB_DIR}" + ) + message(STATUS "添加 ARM 特定的链接选项和 RPATH") +endif() + +# 添加调试信息 +message(STATUS "=======================================") +message(STATUS "Project: ${PROJECT_NAME}") +message(STATUS "ROS 版本: ${ROS_VERSION}") +message(STATUS "Target platform: ${TARGET_PLATFORM}") +message(STATUS "lydHostApi library: ${LYD_HOST_API_LIB}") +message(STATUS "libusb library: ${LIBUSB_LIBRARIES}") +message(STATUS "=======================================") diff --git a/LICENSE b/LICENSE index 261eeb9..54665e1 100644 --- a/LICENSE +++ b/LICENSE @@ -186,7 +186,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright [yyyy] [name of copyright owner] + Copyright 2025 Manifold Tech Ltd. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/README.md b/README.md new file mode 100644 index 0000000..7d328f5 --- /dev/null +++ b/README.md @@ -0,0 +1,235 @@ +# Odin_ROS_Driver Readme + +ROS driver suite for Odin sensor modules (Manifold Tech Ltd.) + +## Odin_ROS_Driver + +Compatibility: + +● ROS 1(LTS Release: Noetic recommended) + +● ROS 2(LTS Release: Humble recommended) + +## Important Notice: + +This driver package provides core functionality for point cloud SLAM applications and targets specific use cases. It is intended exclusively for technical professionals conducting secondary development. End users must perform scenario-specific optimization and custom development to align with operational requirements in practical deployment environments. + +## 1. Version + +Current Version: v0.1 + +## 2. Preparation + +### 2.1 OS Requirement + +● Ubuntu 18.04 for ROS Melodic; + +● Ubuntu 20.04 for ROS Noetic and ROS2 Foxy; + +● Ubuntu 22.04 for ROS2 Humble; + +### 2.2 Dependencies + +● Opencv + +● yaml-cpp + +● thread + +● OpenSSL + +● Eigen3 + +### 2.3 Dependencies Install + +#### 2.3.1 System +```shell +sudo apt update +sudo apt-get install build-essential cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev +``` + +#### 2.3.2 yaml-cpp +```shell +sudo apt update +sudo apt install -y libyaml-cpp-dev +``` + +#### 2.3.3 libusb +```shell +sudo apt update +sudo apt install -y libusb-1.0-0-dev +``` + +#### 2.3.4 opencv +```shell +sudo apt update +sudo apt-get install libopencv-dev +``` + +#### 2.3.4 ROS install +```shell +#Installation method +For ROS Melodic installation, please refer to: ROS Melodic installation instructions +For ROS Noetic installation, please refer to: ROS Noetic installation instructions +For ROS2 Foxy installation, please refer to: ROS Foxy installation instructions +For ROS2 Humble installation, please refer to: ROS Humble installation instructions +``` + +## 3. Preparation + +### 3.1 Create Udev rules +```shell +sudo vim /etc/udev/rules.d/99-odin-usb.rules +``` +Add the following content to the 99-odin-usb.rules file +```shell +SUBSYSTEM=="usb", ATTR{idVendor}=="2207", ATTR{idProduct}=="0019", MODE="0666", GROUP="plugdev +``` +Reload rules and reinsert devices +```shell +sudo udevadm control --reload +sudo udevadm trigger +``` +### 3.2 OS Requirement +```shell +git clone https://github.com/manifoldsdk/odin_ros_driver.git catkin_ws/src/odin_ros_driver +``` +Note: +Please clone the source code into the "[workspace]/src/" folder, otherwise compilation errors will occur. + +### 3.3 make + +#### 3.3.1 ROS1 (Noetic for example): + +```shell +source /opt/ros/noetic/setup.sh +./scripty/build_ros.sh +``` + +#### 3.3.2 ROS2 (Foxy for example): + +```shell +source /opt/ros/foxy/setup.sh +./scripty/build_ros2.sh +``` + +### 3.4 run: + +#### 3.4.1 ROS1 (Noetic for example): + +```shell +source ../../devel/setup.sh +roslaunch odin_ros_driver [launch file] +``` +● odin_ros_driver: package name; + +● launch file: launch file; + +ROS1 Demo Launch Instructions: +```shell +roslaunch odin_ros_driver odin1_ros1.launch +``` +#### 3.4.2 ROS2 (Foxy for example): + +```shell +source ../../install/setup.sh +ros2 launch odin_ros_driver [launch file] +``` +● odin_ros_driver: package name; + +● launch file: launch file; + +ROS2 Demo Launch Instructions: +```shell +ros2 launch odin_ros_driver odin1_ros2.launch.py +``` +## 4. File structure and data format +### 4.1 File structure +```shell +Odin_ROS_Driver/ // ROS1/ROS2 driver package + 3rdparty/ // Third-party libraries + src/ + host_sdk_sample.cpp // Example source code + yaml_parser.cpp // Source code for reading yaml parameters + lib/ + liblydHostApi_amd.a // Static library for AMD platform + liblydHostApi_arm.a // Static library for ARM platform + include/ + host_sdk_sample.h // Example header file + lidar_api_type.h // API data structure header file + lidar_api.h // API function declarations + yaml_parser.h // Parameter file reading header file + config/ + control_command.yaml // control parameter file for driver + launch_ROS1/ + odin1_ros1.launch // ROS1 launch file + launch_ROS2/ + odin1_ros2.launch.py // ROS2 launch file + script/ + build_ros1.sh // Installation script for ROS1 + build_ros2.sh // Installation script for ROS2 + README.md // Usage instructions + CMakeLists.txt // CMake build file + License // License file +``` +### 4.2 File structure +| Launch File Name | Description | +|--------------------------|-------------| +| odin1_ros1.launch | Launch file for ROS1 - Odin1 Basic Operations Demo | +| odin1_ros2.launch.py | Launch file for ROS2 - Odin1 Basic Operations Demo | + +### 4.3 Config file +Internal parameters of the Odin ROS driver are defined in config/control_command.yaml. Below are descriptions of the commonly used parameters: +| Parameter | Detailed Description | Default | +|---------------|----------------------|---------| +| streamctrl: 1 | Master data stream control (0: OFF, 1: ON) | 1 | +| sendrgb:1 | RGB image stream control (0: OFF, 1: ON) | 1 | +| sendimu:1 | IMU (Inertial Measurement Unit) stream control (0: OFF, 1: ON) | 1 | +| sendodom:1 | Odometry data stream control (0: OFF, 1: ON) | 1 | +| senddtof:0 | Raw PointCloud sensor stream control (0: OFF, 1: ON) | 0 | +| sendcloudslam:1 | Slam PointCloud stream control (0: OFF, 1: ON) | 1 | + +### 4.4 ROS topics +Internal parameters of the Odin ROS driver are defined in config/control_command.yaml. Below are descriptions of the commonly used parameters: + +| Topic | Detailed Description | +|---------------------|----------------------| +| odin1/imu | Imu Topic | +| odin1/image | RGB Camera Topic | +| odin1/cloud_raw | Raw_Cloud Topic | +| odin1/cloud_slam | Slam_PointCloud Topic | +| odin1/odometry_map | Odom Topic | + +## 5. FAQ +### 5.1 Segmentation fault upon re-launching host SDK +**Error Message** +Core dump occurs when restarting host SDK after initial successful run + +**Solution** +```shell +power cycle Odin1 # Disconnect and reconnect LiDAR power +reinitialize host SDK # Execute SDK after device reboot +``` + +### 5.2 Library binding failure during compilation + +**Error Message** +ld: cannot find -llydHostApi or symbol lookup errors + +**Resolution** +```shell +Clean previous build artifacts +ROS1 rm -rf devel/ build/ +ROS2 rm -rf devel/ install/ log/ +Re-run script installation (refer to section 2.3) +``` + +### 5.3 Docker GUI passthrough failure + +**Error Message** +Unable to open X display or No protocol specified + +**Resolution** +```shell +xhost + #This command enables graphical passthrough to Docker containers +``` \ No newline at end of file diff --git a/config/control_command.yaml b/config/control_command.yaml new file mode 100644 index 0000000..c3477ce --- /dev/null +++ b/config/control_command.yaml @@ -0,0 +1,7 @@ +register_keys: + streamctrl: 1 + sendrgb: 1 + sendimu: 1 + sendodom: 1 + senddtof: 0 + sendcloudslam: 1 diff --git a/include/host_sdk_sample.h b/include/host_sdk_sample.h new file mode 100644 index 0000000..7faedbe --- /dev/null +++ b/include/host_sdk_sample.h @@ -0,0 +1,549 @@ +/* +Copyright 2025 Manifold Tech Ltd.(www.manifoldtech.com.co) +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "lidar_api.h" +#include "lidar_api_type.h" + + +#ifdef ROS2 + + #include "rclcpp/rclcpp.hpp" + #include "std_msgs/msg/string.hpp" + #include "sensor_msgs/msg/image.hpp" + #include "sensor_msgs/msg/imu.hpp" + #include "sensor_msgs/msg/point_cloud2.hpp" + #include "sensor_msgs/point_cloud2_iterator.hpp" + #include + #include + #include + #include + namespace ros { + using namespace rclcpp; + using namespace std_msgs::msg; + using namespace sensor_msgs::msg; + using namespace nav_msgs::msg; + using Time = builtin_interfaces::msg::Time; + } +#else + + #include + #include + #include + #include + #include + #include + #include + namespace ros { + using namespace ::ros; + using namespace sensor_msgs; + using namespace nav_msgs; + } +#endif + +// 公共定义 +#define GD_ACCL_G 9.7833f +#define ACC_1G_ms2 9.8 +#define ACC_SEN_SCALE 16348 +#define PAI 3.14159265358979323846 +#define GYRO_SEN_SCALE 32.8f + +// 公共函数 +inline float accel_convert(int16_t raw, int sen_scale) { + return (raw * GD_ACCL_G / sen_scale); +} + +inline float gyro_convert(int16_t raw, float sen_scale) { + return (raw * PAI) / (sen_scale * 180); +} + +inline ros::Time ns_to_ros_time(uint64_t timestamp_ns) { + ros::Time t; + #ifdef ROS2 + t.sec = static_cast(timestamp_ns / 1000000000); + t.nanosec = static_cast(timestamp_ns % 1000000000); + #else + t.sec = static_cast(timestamp_ns / 1000000000); + t.nsec = static_cast(timestamp_ns % 1000000000); + #endif + return t; +} + +inline uint64_t ros_time_to_ns(const ros::Time &t) { + #ifdef ROS2 + return static_cast(t.sec) * 1000000000ULL + t.nanosec; + #else + return static_cast(t.sec) * 1000000000ULL + t.nsec; + #endif +} + +// 多传感器发布器类 +class MultiSensorPublisher { +public: + #ifdef ROS2 + MultiSensorPublisher(rclcpp::Node::SharedPtr node) + : node_(node) { + initialize_publishers(); + } + #else + MultiSensorPublisher(ros::NodeHandle& nh) { + initialize_publishers(nh); + } + #endif + + void publishImu(icm_6aixs_data_t *stream) { + #ifdef ROS2 + sensor_msgs::msg::Imu imu_msg; + #else + ros::Imu imu_msg; + #endif + + imu_msg.header.stamp = ns_to_ros_time(stream->stamp); + imu_msg.header.frame_id = "imu_link"; + + imu_msg.linear_acceleration.y = -1 * static_cast(accel_convert(stream->aacx, ACC_SEN_SCALE)); + imu_msg.linear_acceleration.x = static_cast(accel_convert(stream->aacy, ACC_SEN_SCALE)); + imu_msg.linear_acceleration.z = static_cast(accel_convert(stream->aacz, ACC_SEN_SCALE)); + + imu_msg.angular_velocity.y = -1 * static_cast(gyro_convert(stream->gyrox, GYRO_SEN_SCALE)); + imu_msg.angular_velocity.x = static_cast(gyro_convert(stream->gyroy, GYRO_SEN_SCALE)); + imu_msg.angular_velocity.z = static_cast(gyro_convert(stream->gyroz, GYRO_SEN_SCALE)); + + imu_msg.orientation.x = 0.0; + imu_msg.orientation.y = 0.0; + imu_msg.orientation.z = 0.0; + imu_msg.orientation.w = 1.0; + + #ifdef ROS2 + imu_pub_->publish(std::move(imu_msg)); + #else + imu_pub_.publish(imu_msg); + #endif + } + +void publishIntensityCloud(capture_Image_List_t* stream, int idx) +{ + #ifdef ROS2 + sensor_msgs::msg::PointCloud2 msg; + msg.header.frame_id = "map"; + msg.header.stamp = ns_to_ros_time(stream->imageList[0].timestamp); + + msg.height = stream->imageList[idx].height; + msg.width = stream->imageList[idx].width; + msg.is_dense = false; + + sensor_msgs::PointCloud2Modifier modifier(msg); + modifier.setPointCloud2Fields( + 4, + "x", 1, sensor_msgs::msg::PointField::FLOAT32, + "y", 1, sensor_msgs::msg::PointField::FLOAT32, + "z", 1, sensor_msgs::msg::PointField::FLOAT32, + "intensity", 1, sensor_msgs::msg::PointField::UINT8 + ); + modifier.resize(stream->imageList[idx].width * stream->imageList[idx].height); + + sensor_msgs::PointCloud2Iterator iter_x(msg, "x"); + sensor_msgs::PointCloud2Iterator iter_y(msg, "y"); + sensor_msgs::PointCloud2Iterator iter_z(msg, "z"); + sensor_msgs::PointCloud2Iterator iter_intensity(msg, "intensity"); + #else + sensor_msgs::PointCloud2 msg; + msg.header.frame_id = "map"; + msg.header.stamp = ros::Time::now(); // ROS1使用全局时间 + msg.height = stream->imageList[idx].height; + msg.width = stream->imageList[idx].width; + msg.is_dense = false; + msg.is_bigendian = false; + + sensor_msgs::PointCloud2Modifier modifier(msg); + modifier.setPointCloud2Fields( + 4, + "x", 1, sensor_msgs::PointField::FLOAT32, + "y", 1, sensor_msgs::PointField::FLOAT32, + "z", 1, sensor_msgs::PointField::FLOAT32, + "intensity", 1, sensor_msgs::PointField::UINT8 + ); + modifier.resize(msg.height * msg.width); + + sensor_msgs::PointCloud2Iterator iter_x(msg, "x"); + sensor_msgs::PointCloud2Iterator iter_y(msg, "y"); + sensor_msgs::PointCloud2Iterator iter_z(msg, "z"); + sensor_msgs::PointCloud2Iterator iter_intensity(msg, "intensity"); + #endif + + float* xyz_data = static_cast(stream->imageList[idx].pAddr); + uint16_t* intensity_data = static_cast(stream->imageList[2].pAddr); + + int total_points = stream->imageList[idx].height * stream->imageList[idx].width; + for (int i = 0; i < total_points; ++i) { + float* pf = xyz_data + i * 4; + + #ifdef ROS2 + *iter_x = pf[2] / 1000.0f; ++iter_x; + *iter_y = pf[0] / 1000.0f; ++iter_y; + *iter_z = -pf[1] / 1000.0f; ++iter_z; + *iter_intensity = static_cast(intensity_data[i] >> 8); ++iter_intensity; + #else + *iter_x = pf[2] / 1000.0f; ++iter_x; + *iter_y = pf[0] / 1000.0f; ++iter_y; + *iter_z = -pf[1] / 1000.0f; ++iter_z; + *iter_intensity = static_cast(intensity_data[i] >> 8); ++iter_intensity; + #endif + } + + // 发布点云 + #ifdef ROS2 + cloud_pub_->publish(std::move(msg)); + #else + cloud_pub_.publish(msg); + #endif +} + + void publishRgb(capture_Image_List_t *stream) { + buffer_List_t &image = stream->imageList[0]; + + // 验证图像参数 + if (!image.pAddr) { + #ifdef ROS2 + RCLCPP_ERROR(node_->get_logger(), "Invalid RGB image: null data pointer"); + #else + ROS_ERROR("Invalid RGB image: null data pointer"); + #endif + return; + } + + if (image.width <= 0 || image.height <= 0) { + #ifdef ROS2 + RCLCPP_ERROR(node_->get_logger(), "Invalid RGB image dimensions: %dx%d", image.width, image.height); + #else + ROS_ERROR("Invalid RGB image dimensions: %dx%d", image.width, image.height); + #endif + return; + } + + // 计算 NV12 图像高度 + const int height_nv12 = image.height * 3 / 2; + + // 验证 NV12 图像尺寸 + const size_t expected_size = static_cast(image.width) * height_nv12; + if (image.length < expected_size) { + #ifdef ROS2 + RCLCPP_ERROR(node_->get_logger(), "RGB buffer too small: expected %zu bytes, got %u bytes", + expected_size, image.length); + #else + ROS_ERROR("RGB buffer too small: expected %zu bytes, got %u bytes", + expected_size, image.length); + #endif + return; + } + + try { + cv::Mat nv12_mat(height_nv12, image.width, CV_8UC1, image.pAddr); + cv::Mat bgr; + cv::cvtColor(nv12_mat, bgr, cv::COLOR_YUV2BGR_NV12); + + if (bgr.empty()) { + #ifdef ROS2 + RCLCPP_ERROR(node_->get_logger(), "Failed to convert NV12 to BGR"); + #else + ROS_ERROR("Failed to convert NV12 to BGR"); + #endif + return; + } + + #ifdef ROS2 + std_msgs::msg::Header header; + sensor_msgs::msg::Image::SharedPtr msg; + #else + std_msgs::Header header; + sensor_msgs::Image msg; + #endif + + header.stamp = ns_to_ros_time(image.timestamp + 719060); + header.frame_id = "camera_rgb_frame"; + + #ifdef ROS2 + auto cv_image = std::make_shared(header, "bgr8", bgr); + msg = cv_image->toImageMsg(); + rgb_pub_->publish(*msg); + #else + cv_bridge::CvImage(header, "bgr8", bgr).toImageMsg(msg); + rgb_pub_.publish(msg); + #endif + + } catch (const cv::Exception& e) { + #ifdef ROS2 + RCLCPP_ERROR(node_->get_logger(), "OpenCV error in publishRgb: %s", e.what()); + #else + ROS_ERROR("OpenCV error in publishRgb: %s", e.what()); + #endif + } catch (const std::exception& e) { + #ifdef ROS2 + RCLCPP_ERROR(node_->get_logger(), "Exception in publishRgb: %s", e.what()); + #else + ROS_ERROR("Exception in publishRgb: %s", e.what()); + #endif + } + } + +void publishPC2XYZRGBA(capture_Image_List_t* stream, int idx) +{ + static int flag = 1; + #ifdef ROS2 + sensor_msgs::msg::PointCloud2 msg; + // msg.header.frame_id = "base_link"; + msg.header.frame_id = "map"; + msg.header.stamp = ns_to_ros_time(stream->imageList[0].timestamp); + // msg.header.stamp = this->now(); + size_t pt_size = sizeof(int32_t) * 3 + sizeof(int32_t) * 4; + uint32_t points = stream->imageList[idx].length / pt_size; + + msg.height = 1; + msg.width = points; + msg.is_dense = false; + // LOG_INFO("msg.height=%ld, msg.width=%ld.\n", msg.height, msg.width); + + sensor_msgs::PointCloud2Modifier modifier(msg); + modifier.setPointCloud2Fields( + 4, + "x", 1, sensor_msgs::msg::PointField::FLOAT32, + "y", 1, sensor_msgs::msg::PointField::FLOAT32, + "z", 1, sensor_msgs::msg::PointField::FLOAT32, + "rgb", 1, sensor_msgs::msg::PointField::FLOAT32 + ); + modifier.resize(msg.width * msg.height); + + sensor_msgs::PointCloud2Iterator iter_x(msg, "x"); + sensor_msgs::PointCloud2Iterator iter_y(msg, "y"); + sensor_msgs::PointCloud2Iterator iter_z(msg, "z"); + sensor_msgs::PointCloud2Iterator iter_rgb(msg, "rgb"); + #else + sensor_msgs::PointCloud2 msg; + msg.header.frame_id = "map"; + msg.header.stamp = ns_to_ros_time(stream->imageList[0].timestamp); + + size_t pt_size = sizeof(int32_t) * 3 + sizeof(int32_t) * 4; + uint32_t points = stream->imageList[idx].length / pt_size; + + msg.height = 1; + msg.width = points; + msg.is_dense = false; + + sensor_msgs::PointCloud2Modifier modifier(msg); + modifier.setPointCloud2Fields( + 4, + "x", 1, sensor_msgs::PointField::FLOAT32, + "y", 1, sensor_msgs::PointField::FLOAT32, + "z", 1, sensor_msgs::PointField::FLOAT32, + "rgb", 1, sensor_msgs::PointField::FLOAT32 + ); + modifier.resize(msg.width * msg.height); + + sensor_msgs::PointCloud2Iterator iter_x(msg, "x"); + sensor_msgs::PointCloud2Iterator iter_y(msg, "y"); + sensor_msgs::PointCloud2Iterator iter_z(msg, "z"); + sensor_msgs::PointCloud2Iterator iter_rgb(msg, "rgb"); + #endif + + // 共享的数据处理逻辑 + int32_t* xyz_data = static_cast(stream->imageList[idx].pAddr); + + for(uint32_t i = 0; i < points; i++) { + int32_t* ptr = xyz_data + 7*i; + + #ifdef ROS2 + *iter_x = static_cast(ptr[0]) / 10000.0f; ++iter_x; + *iter_y = static_cast(ptr[1]) / 10000.0f; ++iter_y; + *iter_z = static_cast(ptr[2]) / 10000.0f; ++iter_z; + #else + *iter_x = (1.0 * ptr[0]) / 1e4; ++iter_x; + *iter_y = (1.0 * ptr[1]) / 1e4; ++iter_y; + *iter_z = (1.0 * ptr[2]) / 1e4; ++iter_z; + #endif + + uint8_t r = ptr[3] & 0xff; + uint8_t g = ptr[4] & 0xff; + uint8_t b = ptr[5] & 0xff; + + uint32_t packed_rgb = (static_cast(r) << 16) | + (static_cast(g) << 8) | + static_cast(b); + + float rgb_float; + std::memcpy(&rgb_float, &packed_rgb, sizeof(float)); + + *iter_rgb = rgb_float; ++iter_rgb; + } + + #ifdef ROS2 + flag = 0; // 如果flag在其他地方使用，保留赋值 + xyzrgbacloud_pub_->publish(std::move(msg)); + #else + flag = 0; + xyzrgbacloud_pub_.publish(msg); + #endif +} + + void publishOdometry(capture_Image_List_t* stream) { + ros2_odom_convert_t* odom_data = (ros2_odom_convert_t*)stream->imageList[0].pAddr; + + #ifdef ROS2 + auto msg = nav_msgs::msg::Odometry(); + #else + ros::Odometry msg; + #endif + + msg.header.stamp = ns_to_ros_time(odom_data->timestamp_ns); + msg.header.frame_id = "map"; + msg.child_frame_id = "base_link"; + + msg.pose.pose.position.x = static_cast(odom_data->pos[0]) / 1e6; + msg.pose.pose.position.y = static_cast(odom_data->pos[1]) / 1e6; + msg.pose.pose.position.z = static_cast(odom_data->pos[2]) / 1e6; + + msg.pose.pose.orientation.x = static_cast(odom_data->orient[0]) / 1e6; + msg.pose.pose.orientation.y = static_cast(odom_data->orient[1]) / 1e6; + msg.pose.pose.orientation.z = static_cast(odom_data->orient[2]) / 1e6; + msg.pose.pose.orientation.w = static_cast(odom_data->orient[3]) / 1e6; + + #ifdef ROS2 + odom_publisher_->publish(std::move(msg)); + #else + odom_publisher_.publish(msg); + #endif + } + +private: + void initialize_publishers() { + #ifdef ROS2 + imu_pub_ = node_->create_publisher("odin1/imu", 10); + rgb_pub_ = node_->create_publisher("odin1/image", 10); + cloud_pub_ = node_->create_publisher("odin1/cloud_raw", 10); + xyzrgbacloud_pub_ = node_->create_publisher("odin1/cloud_slam", 10); + odom_publisher_ = node_->create_publisher("odin1/odometry_map", 10); + #endif + } + + #ifdef ROS1 + void initialize_publishers(ros::NodeHandle& nh) { + imu_pub_ = nh.advertise("odin1/imu", 10); + rgb_pub_ = nh.advertise("odin1/image", 10); + cloud_pub_ = nh.advertise("odin1/cloud_raw", 10); + xyzrgbacloud_pub_ = nh.advertise("odin1/cloud_slam", 10); + odom_publisher_ = nh.advertise("odin1/odometry_map", 10); + } + #endif + + #ifdef ROS2 + rclcpp::Node::SharedPtr node_; + rclcpp::Publisher::SharedPtr imu_pub_; + rclcpp::Publisher::SharedPtr rgb_pub_; + rclcpp::Publisher::SharedPtr cloud_pub_; + rclcpp::Publisher::SharedPtr xyzrgbacloud_pub_; + rclcpp::Publisher::SharedPtr odom_publisher_; + #else + ros::Publisher imu_pub_; + ros::Publisher rgb_pub_; + ros::Publisher cloud_pub_; + ros::Publisher xyzrgbacloud_pub_; + ros::Publisher odom_publisher_; + #endif +}; + +// 命令行控制类 +class CommandLineControl { +public: + using Callback = std::function; + + + void register_key(const std::string& key, int default_value = 0) { + std::lock_guard lock(mtx); + kv_map[key] = default_value; + } + + void set(const std::string& key, int value) { + Callback cb_to_invoke = nullptr; + { + std::lock_guard lock(mtx); + auto it = kv_map.find(key); + if (it != kv_map.end()) { + if (it->second != value) { + it->second = value; + std::cout << "Set " << key << " = " << value << std::endl; + cb_to_invoke = callback; + } else { + std::cout << "Set ignored: " << key << " is already " << value << std::endl; + } + } else { + std::cout << "Unknown key: " << key << std::endl; + return; + } + } + + if (cb_to_invoke) { + cb_to_invoke(key, value); + } + } + + int get(const std::string& key) const { + std::lock_guard lock(mtx); + auto it = kv_map.find(key); + return (it != kv_map.end()) ? it->second : -1; + } + + void print_all() const { + std::lock_guard lock(mtx); + std::cout << "Available keys and values:" << std::endl; + for (const auto& [key, value] : kv_map) { + std::cout << " " << key << " = " << value << std::endl; + } + } + + void register_callback(Callback cb) { + std::lock_guard lock(mtx); + callback = cb; + } + +private: + std::unordered_map kv_map; + std::thread input_thread; + std::atomic running; + mutable std::mutex mtx; + Callback callback; + +}; + +// 控制命令定义 +#define STREAMCTRL "streamctrl" /* start/stop all streams */ +#define SENDRGB "sendrgb" /* send RGB data */ +#define SENDIMU "sendimu" /* send IMU data */ +#define SENDODOM "sendodom" /* send odometry data */ +#define SENDDTOF "senddtof" /* send raw cloud data */ +#define SENDCLOUDSLAM "sendcloudslam" /* send rgb cloud data */ +#define EXIT "q" /* exit sample */ diff --git a/include/lidar_api.h b/include/lidar_api.h new file mode 100644 index 0000000..c19647c --- /dev/null +++ b/include/lidar_api.h @@ -0,0 +1,216 @@ +/* +Copyright 2025 Manifold Tech Ltd.(www.manifoldtech.com.co) +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +#ifndef LIDAR_API_H +#define LIDAR_API_H + +/** + * @file lidar_api.h + * @brief LiDAR device API for controlling and accessing LiDAR sensor data + * + * This header provides the public interface for interacting with LiDAR devices. + * It includes functions for device management, data streaming control, and + * device configuration. + * + * @copyright Copyright (c) 2025, Manifold Tech Limited, All Rights Reserved + * @version 1.0 + */ + +#include "lidar_api_type.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Initialize the LiDAR system + * + * Must be called before any other lidar function to set up the system resources. + * + * @param cb Callback function for device events (connection, disconnection) + * @return int 0 on success, negative error code on failure + */ +int lidar_system_init(lidar_device_callback_t cb); + +/** + * @brief Deinitialize the LiDAR system + * + * Releases all resources allocated by the system. Should be called when + * application is shutting down. + * + * @return int 0 on success, negative error code on failure + */ +int lidar_system_deinit(void); + +/** + * @brief Create a handle for a LiDAR device + * + * @param dev_info Information about the LiDAR device to create + * @param device Pointer to receive the device handle upon success + * @return int 0 on success, negative error code on failure + */ +int lidar_create_device(lidar_device_info_t *dev_info, device_handle *device); + +/** + * @brief Destroy a LiDAR device handle + * + * Releases resources associated with the device handle. Must be called + * when the device is no longer needed. + * + * @param device Handle to the device to destroy + * @return int 0 on success, negative error code on failure + */ +int lidar_destory_device(device_handle device); + +/** + * @brief Register callback function for receiving LiDAR data streams + * + * Sets up a callback function that will be called when new data is available. + * + * @param device Handle to the target device + * @param cb Callback information containing function pointers for different data types + * @return int 0 on success, negative error code on failure + */ +int lidar_register_stream_callback(device_handle device, lidar_data_callback_info_t cb); + +/** + * @brief Unregister stream callback for a device + * + * Stops the device from calling back when new data is available. + * + * @param device Handle to the target device + * @return int 0 on success, negative error code on failure + */ +int lidar_unregister_stream_callback(device_handle device); + +/** + * @brief Open a LiDAR device for communication + * + * Establishes a connection to the physical device. + * + * @param device Handle to the device to open + * @return int 0 on success, negative error code on failure + */ +int lidar_open_device(device_handle device); + +/** + * @brief Close a LiDAR device + * + * Closes the connection to the physical device. + * + * @param device Handle to the device to close + * @return int 0 on success, negative error code on failure + */ +int lidar_close_device(device_handle device); + +/** + * @brief Set the operating mode of the LiDAR device + * + * @param device Handle to the target device + * @param mode Operating mode to set (see mode definitions in lidar_api_type.h) + * @return int 0 on success, negative error code on failure + */ +int lidar_set_mode(device_handle device, int mode); + +/** + * @brief Start data streaming from the device + * + * Begins the flow of data from the device for the specified type. + * + * @param device Handle to the target device + * @param type Type of data stream to start (see stream type definitions in lidar_api_type.h) + * @return int 0 on success, negative error code on failure + */ +int lidar_start_stream(device_handle device, int type); + +/** + * @brief Stop data streaming from the device + * + * Stops the flow of data from the device for the specified type. + * + * @param device Handle to the target device + * @param type Type of data stream to stop + * @return int 0 on success, negative error code on failure + */ +int lidar_stop_stream(device_handle device, int type); + +/** + * @brief Activate a specific stream type on the device + * + * Enables a specific data stream type in the device configuration. + * + * @param device Handle to the target device + * @param type Type of data stream to activate + * @return int 0 on success, negative error code on failure + */ +int lidar_activate_stream_type(device_handle device, int type); + +/** + * @brief Deactivate a specific stream type on the device + * + * Disables a specific data stream type in the device configuration. + * + * @param device Handle to the target device + * @param type Type of data stream to deactivate + * @return int 0 on success, negative error code on failure + */ +int lidar_deactivate_stream_type(device_handle device, int type); + +/** + * @brief Perform over-the-air firmware update + * + * Updates the device firmware using the specified file. + * + * @param device Handle to the target device + * @param type Type of OTA update to perform + * @param filepath Path to the firmware file + * @param process_cb Callback function to report update progress + * @return int 0 on success, negative error code on failure + */ +int lidar_ota_update(device_handle device, lidar_ota_type_e type, const char* filepath, void(*process_cb)(float process)); + +/** + * @brief Get device calibration parameters + * + * Retrieves the current calibration parameters from the device. + * + * @param device Handle to the target device + * @param param Pointer to receive the calibration parameters + * @return int 0 on success, negative error code on failure + */ +int lidar_get_calibration(device_handle device, lidar_calibration_t* param); + +/** + * @brief Set device calibration parameters + * + * Applies new calibration parameters to the device. + * + * @param device Handle to the target device + * @param param Pointer to the calibration parameters to set + * @return int 0 on success, negative error code on failure + */ +int lidar_set_calibration(device_handle device, const lidar_calibration_t *param); + +/** + * @brief Set log verbosity level + * + * Controls the amount of log information generated by the LiDAR API. + * + * @param level Log level to set (see level definitions in lidar_api_type.h) + */ +void lidar_log_set_level(lidar_log_level_e level); + +#ifdef __cplusplus +} +#endif + +#endif // LIDAR_API_H \ No newline at end of file diff --git a/include/lidar_api_type.h b/include/lidar_api_type.h new file mode 100644 index 0000000..0bb5315 --- /dev/null +++ b/include/lidar_api_type.h @@ -0,0 +1,131 @@ +/* +Copyright 2025 Manifold Tech Ltd.(www.manifoldtech.com.co) +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +#ifndef LIDAR_TYPES_H +#define LIDAR_TYPES_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define LIDAR_SERIAL_MAX 64 +#define LIDAR_MODEL_MAX 64 +#define LIDAR_IP_MAX 64 + +typedef void * device_handle; + +typedef enum { + LIDAR_LOG_ERROR = 0, + LIDAR_LOG_WARN, + LIDAR_LOG_INFO, + LIDAR_LOG_DEBUG, +} lidar_log_level_e; + +typedef enum { + LIDAR_OTA_ALGORITHM, + LIDAR_OTA_FIRMWARE, + LIDAR_OTA_SCRIPT, + LIDAR_OTA_CALIBRATION +} lidar_ota_type_e; + +typedef enum { + LIDAR_MODE_RAW, + LIDAR_MODE_SLAM, +} lidar_mode_e; + +typedef enum { + LIDAR_DT_NONE = 0, + LIDAR_DT_RAW_RGB = 1 << 1, + LIDAR_DT_RAW_IMU = 1 << 2, + LIDAR_DT_RAW_DTOF = 1 << 3, + LIDAR_DT_SLAM_CLOUD = 1 << 4, + LIDAR_DT_SLAM_ODOMETRY = 1 << 5, +} lidar_data_type_e; + +typedef struct { + int8_t serial[LIDAR_SERIAL_MAX]; + int8_t model[LIDAR_MODEL_MAX]; + bool online; +} lidar_device_info_t; + +typedef struct { + float x, y, z; + float intensity; +} lidar_point_t; + + +typedef struct { + float intrinsics[9]; + float extrinsics[16]; +} lidar_calibration_t; + + +#define DEVICE_MAX_CH_NUMBER 4 + +typedef struct { + uint64_t timestamp_ns; + int64_t pos[3]; + int64_t orient[4]; +} ros2_odom_convert_t; + +typedef struct icm_6aixs_data_t { + int16_t aacx; + int16_t aacy; + int16_t aacz; + int16_t gyrox; + int16_t gyroy; + int16_t gyroz; + uint8_t valid; + uint32_t nums; + uint8_t fsync_pack; + uint16_t interval; + uint64_t stamp; +} icm_6aixs_data_t; + + typedef struct { + uint32_t length; + uint64_t sequence; + uint64_t timestamp; + uint64_t interval; + void* pAddr; + uint32_t width; + uint32_t height; +} buffer_List_t; + +typedef struct capture_Image_List_t { + uint32_t imageCount; + buffer_List_t imageList[DEVICE_MAX_CH_NUMBER]; +} capture_Image_List_t; + +typedef struct { + uint32_t type; + capture_Image_List_t stream; +} lidar_data_t; + +typedef void (*lidar_device_callback_t)(const lidar_device_info_t* device, bool attach); +typedef void (*lidar_data_callback_t)(const lidar_data_t *data, void *user_data); + +typedef struct { + lidar_data_callback_t data_callback; + void *user_data; +} lidar_data_callback_info_t; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/yaml_parser.h b/include/yaml_parser.h new file mode 100644 index 0000000..887c980 --- /dev/null +++ b/include/yaml_parser.h @@ -0,0 +1,38 @@ +/* +Copyright 2025 Manifold Tech Ltd.(www.manifoldtech.com.co) +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +#ifndef YAML_PARSER_H +#define YAML_PARSER_H + +#include +#include +#include + +namespace odin_ros_driver { + +class YamlParser { +public: + // 使用一致的成员变量名 + YamlParser(const std::string& config_file); + + bool loadConfig(); + const std::map& getRegisterKeys() const; + void printConfig() const; + +private: + std::string config_file_; + std::map register_keys_; +}; + +} // namespace odin_ros_driver + +#endif // YAML_PARSER_H \ No newline at end of file diff --git a/launch_ROS1/odin1_ros1.launch b/launch_ROS1/odin1_ros1.launch new file mode 100644 index 0000000..d978903 --- /dev/null +++ b/launch_ROS1/odin1_ros1.launch @@ -0,0 +1,12 @@ + + + + + + + + + + diff --git a/launch_ROS2/odin1_ros2.launch.py b/launch_ROS2/odin1_ros2.launch.py new file mode 100644 index 0000000..a7e1301 --- /dev/null +++ b/launch_ROS2/odin1_ros2.launch.py @@ -0,0 +1,38 @@ + +#用法: ros2 launch odin_ros_driver odin1_ros2.launch.py +import os +from ament_index_python.packages import get_package_share_directory +from launch import LaunchDescription +from launch.actions import DeclareLaunchArgument +from launch.substitutions import LaunchConfiguration +from launch_ros.actions import Node + +def generate_launch_description(): + # 获取包目录 + package_dir = get_package_share_directory('odin_ros_driver') + + # 声明配置参数 + config_file_arg = DeclareLaunchArgument( + 'config_file', + default_value=os.path.join(package_dir, 'config', 'control_command.yaml'), + description='Path to the control config YAML file' + ) + + # 创建节点 + host_sdk_node = Node( + package='odin_ros_driver', + executable='host_sdk_sample', + name='host_sdk_sample', + output='screen', + # arguments=['--ros-args', '--log-level', 'debug'], + parameters=[{ + 'config_file': LaunchConfiguration('config_file') + }] + ) + + # 创建启动描述 + ld = LaunchDescription() + ld.add_action(config_file_arg) + ld.add_action(host_sdk_node) + + return ld diff --git a/lib/liblydHostApi_amd.a b/lib/liblydHostApi_amd.a new file mode 100644 index 0000000000000000000000000000000000000000..f0fa0ff91e1571ce0eafafcba67c3a228e2660e1 GIT binary patch literal 253790 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 literal 0 HcmV?d00001 diff --git a/lib/liblydHostApi_arm.a b/lib/liblydHostApi_arm.a new file mode 100644 index 0000000000000000000000000000000000000000..8affc9079f90926deb9c1c219f693485bcbf6b51 GIT binary patch literal 268474 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 PP2-zx#gR4pp^yJxHHoVs literal 0 HcmV?d00001 diff --git a/package_ros1.xml b/package_ros1.xml new file mode 100644 index 0000000..92c28a1 --- /dev/null +++ b/package_ros1.xml @@ -0,0 +1,29 @@ + + + odin_ros_driver + 0.0.1 + ROS driver for Odin sensor + rlk + Apache 2.0 + + + catkin + + + roscpp + std_msgs + sensor_msgs + nav_msgs + cv_bridge + image_transport + + + eigen + opencv + yaml-cpp + + + + catkin + + diff --git a/package_ros2.xml b/package_ros2.xml new file mode 100644 index 0000000..5d5f028 --- /dev/null +++ b/package_ros2.xml @@ -0,0 +1,22 @@ + + + odin_ros_driver + 0.0.1 + ROS2 driver for Odin sensor + rlk + Apache 2.0 + + ament_cmake + + rclcpp + + std_msgs + sensor_msgs + nav_msgs + cv_bridge + image_transport + + + ament_cmake + + \ No newline at end of file diff --git a/script/build_ros.sh b/script/build_ros.sh new file mode 100644 index 0000000..56479ab --- /dev/null +++ b/script/build_ros.sh @@ -0,0 +1,128 @@ +#!/bin/bash + +# 获取脚本所在目录（Odin_ROS_Driver 目录） +PKG_DIR="$(cd "$(dirname "$0")/.."; pwd)" +# 计算工作空间根目录（包含 devel、build、src 的目录） +WORKSPACE_ROOT="$(dirname "$(dirname "$PKG_DIR")")" +# 工作空间源码目录（包含所有包的 src） +WORKSPACE_SRC="${WORKSPACE_ROOT}/src" +PROJECT_NAME="odin_ros_driver" + +# 定义颜色代码 +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +NC='\033[0m' # 无颜色 + +# 清理函数 +clean_workspace() { + echo -e "${YELLOW}🧹 清理构建目录${NC}" + + # 清理工作空间根目录下的构建产物 + rm -rf "${WORKSPACE_ROOT}/build" + rm -rf "${WORKSPACE_ROOT}/install" + rm -rf "${WORKSPACE_ROOT}/log" + rm -rf "${WORKSPACE_ROOT}/devel" + + echo -e "${GREEN}✅ 清理完成${NC}" +} + +# 运行函数 +run_node() { + echo -e "${YELLOW}🏃‍♂️‍➡️ 运行 ROS1 节点${NC}" + + # 检查环境文件是否存在 + if [ ! -f "${WORKSPACE_ROOT}/devel/setup.bash" ]; then + echo -e "${RED}❌ 找不到 devel/setup.bash，请先执行 ./build_ros1.sh 构建项目${NC}" + return 1 + fi + + # Source 环境并运行节点 + source "${WORKSPACE_ROOT}/devel/setup.bash" + +} + +# 构建函数 +build_workspace() { + echo -e "${YELLOW}🔍 工作空间结构:${NC}" + echo " 工作空间根目录: ${WORKSPACE_ROOT}" + echo " 源码目录: ${WORKSPACE_SRC}" + echo " 包目录: ${PKG_DIR}" + echo " ROS版本: ROS1" + + echo -e "${YELLOW}🔧 开始构建 ROS1 工程...${NC}" + + # 清理 + cd $WS_DIR + rm -rf build devel install + + # 确保 ROS1 环境已加载 + if [ -f "/opt/ros/noetic/setup.bash" ]; then + source "/opt/ros/noetic/setup.bash" + elif [ -f "/opt/ros/melodic/setup.bash" ]; then + source "/opt/ros/melodic/setup.bash" + else + echo -e "${RED}❌ 找不到 ROS1 的 setup.bash 文件。请确保 ROS1 已安装。${NC}" + return 1 + fi + + # 创建临时 package.xml + if [ -f "${PKG_DIR}/package_ros1.xml" ]; then + echo "🔄 创建临时 package.xml（使用 package_ros1.xml）" + cp "${PKG_DIR}/package_ros1.xml" "${PKG_DIR}/package.xml" + TEMP_PACKAGE=true + elif [ -f "${PKG_DIR}/package.xml" ]; then + echo "ℹ️ 使用现有的 package.xml" + else + echo -e "${RED}❌ 在包目录中找不到 package.xml${NC}" + return 1 + fi + + # 设置构建系统变量 + export BUILD_SYSTEM=ROS1 + + # 切换到工作空间根目录并构建 + cd "${WORKSPACE_ROOT}" || return 1 + catkin_make -DBUILD_SYSTEM=ROS1 -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -j$(nproc) + BUILD_RESULT=$? + + # 构建成功，source 环境 + if [[ $BUILD_RESULT -eq 0 ]]; then + echo -e "${GREEN}✅ ROS1 构建成功，载入环境变量：source devel/setup.bash${NC}" + source "${WORKSPACE_ROOT}/devel/setup.bash" + else + echo -e "${RED}❌ ROS1 构建失败，请检查错误日志${NC}" + fi + + +} + +# 帮助函数 +show_help() { + echo -e "${YELLOW}使用说明:${NC}" + echo " ./build_ros.sh # 构建项目" + echo " ./build_ros.sh -c # 清理构建产物" + echo " ./build_ros.sh -h # 显示帮助信息" + echo "" + echo -e "${YELLOW}当前配置:${NC}" + echo " 项目名称: ${PROJECT_NAME}" + echo " 包目录: ${PKG_DIR}" + echo " 工作空间根目录: ${WORKSPACE_ROOT}" + echo " 源码目录: ${WORKSPACE_SRC}" +} + +# 主程序 +case "$1" in + -c|--clean) + clean_workspace + ;; + -r|--run) + run_node + ;; + -h|--help) + show_help + ;; + *) + build_workspace + ;; +esac \ No newline at end of file diff --git a/script/build_ros2.sh b/script/build_ros2.sh new file mode 100644 index 0000000..2253102 --- /dev/null +++ b/script/build_ros2.sh @@ -0,0 +1,158 @@ +#!/bin/bash + +# 获取脚本所在目录（Odin_ROS_Driver 目录） +PKG_DIR="$(cd "$(dirname "$0")/.."; pwd)" +# 计算工作空间根目录（包含 devel、build、src 的目录） +WORKSPACE_ROOT="$(dirname "$(dirname "$PKG_DIR")")" +# 工作空间源码目录（包含所有包的 src） +WORKSPACE_SRC="${WORKSPACE_ROOT}/src" +PROJECT_NAME="odin_ros_driver" +PACKAGE_DIR_NAME=$(basename "$PKG_DIR") + +# 定义颜色代码 +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +NC='\033[0m' # 无颜色 + +# 从 package.xml 中提取包名 +get_package_name() { + local package_xml="$1" + if [ -f "$package_xml" ]; then + # 提取 标签内容 + grep -oP '\K[^<]+' "$package_xml" | head -1 + else + echo "" + fi +} + +# 清理函数 +clean_workspace() { + echo -e "${YELLOW}🧹 清理构建目录${NC}" + + # 清理工作空间根目录下的构建产物 + rm -rf "${WORKSPACE_ROOT}/build" + rm -rf "${WORKSPACE_ROOT}/install" + rm -rf "${WORKSPACE_ROOT}/log" + rm -rf "${WORKSPACE_ROOT}/devel" + + echo -e "${GREEN}✅ 清理完成${NC}" +} + +# 运行函数 +run_node() { + echo -e "${YELLOW}🏃‍♂️‍➡️ 运行 ROS2 节点${NC}" + + # 检查环境文件是否存在 + if [ ! -f "${WORKSPACE_ROOT}/install/setup.bash" ]; then + echo -e "${RED}❌ 找不到 install/setup.bash，请先执行 ./build_ros2.sh 构建项目${NC}" + return 1 + fi + + # Source 环境并运行节点 + source "${WORKSPACE_ROOT}/install/setup.bash" + +} + +# 构建函数 +build_workspace() { + echo -e "${YELLOW}🔍 工作空间结构:${NC}" + echo " 工作空间根目录: ${WORKSPACE_ROOT}" + echo " 源码目录: ${WORKSPACE_SRC}" + echo " 包目录: ${PKG_DIR}" + echo " 目录名: ${PACKAGE_DIR_NAME}" + echo " ROS版本: ROS2" + + echo -e "${YELLOW}🔧 开始构建 ROS2 工程...${NC}" + # 清理 + cd $WS_DIR + rm -rf build install log + # 确保 ROS2 环境已加载 + if [ -f "/opt/ros/foxy/setup.bash" ]; then + source "/opt/ros/foxy/setup.bash" + elif [ -f "/opt/ros/galactic/setup.bash" ]; then + source "/opt/ros/galactic/setup.bash" + elif [ -f "/opt/ros/humble/setup.bash" ]; then + source "/opt/ros/humble/setup.bash" + else + echo -e "${RED}❌ 找不到 ROS2 的 setup.bash 文件。请确保 ROS2 已安装。${NC}" + return 1 + fi + + # 创建临时 package.xml + if [ -f "${PKG_DIR}/package_ros2.xml" ]; then + echo "🔄 创建临时 package.xml（使用 package_ros2.xml）" + cp "${PKG_DIR}/package_ros2.xml" "${PKG_DIR}/package.xml" + TEMP_PACKAGE=true + elif [ -f "${PKG_DIR}/package.xml" ]; then + echo "ℹ️ 使用现有的 package.xml" + TEMP_PACKAGE=false + else + echo -e "${RED}❌ 在包目录中找不到 package.xml${NC}" + return 1 + fi + + # 从 package.xml 中提取包名 + PACKAGE_NAME=$(get_package_name "${PKG_DIR}/package.xml") + if [ -z "$PACKAGE_NAME" ]; then + echo -e "${RED}❌ 无法从 package.xml 中提取包名${NC}" + return 1 + fi + echo " 包名: ${PACKAGE_NAME}" + + # 设置构建系统变量 + export BUILD_SYSTEM=ROS2 + + # 切换到工作空间根目录并构建 + cd "${WORKSPACE_ROOT}" || return 1 + + # 使用正确的包名构建 + colcon build \ + --packages-select "${PACKAGE_NAME}" \ + --parallel-workers $(nproc) \ + --cmake-args \ + -DBUILD_SYSTEM=ROS2 \ + -DCMAKE_EXPORT_COMPILE_COMMANDS=ON + + BUILD_RESULT=$? + + # 构建成功，source 环境 + if [[ $BUILD_RESULT -eq 0 ]]; then + echo -e "${GREEN}✅ ROS2 构建成功，载入环境变量：source install/setup.bash${NC}" + source "${WORKSPACE_ROOT}/install/setup.bash" + + else + echo -e "${RED}❌ ROS2 构建失败，请检查错误日志${NC}" + fi + +} + +# 帮助函数 +show_help() { + echo -e "${YELLOW}使用说明:${NC}" + echo " ./build_ros2.sh # 构建项目" + echo " ./build_ros2.sh -c # 清理构建产物" + echo " ./build_ros2.sh -h # 显示帮助信息" + echo "" + echo -e "${YELLOW}当前配置:${NC}" + echo " 项目名称: ${PROJECT_NAME}" + echo " 包目录: ${PKG_DIR}" + echo " 工作空间根目录: ${WORKSPACE_ROOT}" + echo " 源码目录: ${WORKSPACE_SRC}" +} + +# 主程序 +case "$1" in + -c|--clean) + clean_workspace + ;; + -r|--run) + run_node + ;; + -h|--help) + show_help + ;; + *) + build_workspace + ;; +esac \ No newline at end of file diff --git a/src/host_sdk_sample.cpp b/src/host_sdk_sample.cpp new file mode 100644 index 0000000..cdf93fd --- /dev/null +++ b/src/host_sdk_sample.cpp @@ -0,0 +1,330 @@ +#include "host_sdk_sample.h" +#include "yaml_parser.h" +#include +#include +#include +#include +#include + +#ifdef ROS2 + #include +#else + #include +#endif + +static device_handle odinDevice = nullptr; +static std::shared_ptr g_ros_object; +static std::atomic deviceConnected(false); + +// 定义获取包路径的函数 +std::string get_package_share_path(const std::string& package_name) { +#ifdef ROS2 + try { + return ament_index_cpp::get_package_share_directory(package_name); + } catch (const std::exception& e) { + throw std::runtime_error("Package not found: " + std::string(e.what())); + } +#else + try { + return ros::package::getPath(package_name); + } catch (const ros::InvalidNameException& e) { + throw std::runtime_error("Package not found: " + std::string(e.what())); + } +#endif +} + +// 全局配置变量 +static int g_sendrgb = 1; +static int g_sendimu = 1; +static int g_senddtof = 1; +static int g_sendodom = 1; +static int g_sendcloudslam = 0; + +static void lidar_data_callback(const lidar_data_t *data, void *user_data) +{ + device_handle *dev_handle = static_cast(user_data); + if(!dev_handle || !data) { + printf("Invalid device handle or data.\n"); + return; + } + + switch(data->type) { + case LIDAR_DT_NONE: + printf("empty lidar data type: %x\n", data->type); + break; + case LIDAR_DT_RAW_RGB: + if (g_sendrgb) { + g_ros_object->publishRgb((capture_Image_List_t *)&data->stream); + } + break; + case LIDAR_DT_RAW_IMU: + if (g_sendimu) { + g_ros_object->publishImu((icm_6aixs_data_t *)data->stream.imageList[0].pAddr); + } + break; + case LIDAR_DT_RAW_DTOF: + if (g_senddtof) { + g_ros_object->publishIntensityCloud((capture_Image_List_t *)&data->stream, 1); + } + break; + case LIDAR_DT_SLAM_CLOUD: + if (g_sendcloudslam) { + g_ros_object->publishPC2XYZRGBA((capture_Image_List_t *)&data->stream, 0); + } + break; + case LIDAR_DT_SLAM_ODOMETRY: + if (g_sendodom) { + g_ros_object->publishOdometry((capture_Image_List_t *)&data->stream); + } + break; + default: + printf("Unknown lidar data type: %x", data->type); + return; + } +} + +static void lidar_device_callback(const lidar_device_info_t* device, bool attach) +{ + int type = LIDAR_MODE_SLAM; + if(attach == true) { + #ifdef ROS2 + RCLCPP_INFO(rclcpp::get_logger("device_cb"), "Device attaching..."); + #else + ROS_INFO("Device attaching..."); + #endif + + // 清理任何已存在的设备 + if (odinDevice) { + lidar_stop_stream(odinDevice, type); + lidar_unregister_stream_callback(odinDevice); + lidar_close_device(odinDevice); + lidar_destory_device(odinDevice); + odinDevice = nullptr; + } + + // 修复：使用const_cast移除const限定符 + if (lidar_create_device(const_cast(device), &odinDevice)) { + #ifdef ROS2 + RCLCPP_ERROR(rclcpp::get_logger("device_cb"), "Create device failed"); + #else + ROS_ERROR("Create device failed"); + #endif + return; + } + + // 打开设备 + if (lidar_open_device(odinDevice)) { + #ifdef ROS2 + RCLCPP_ERROR(rclcpp::get_logger("device_cb"), "Open device failed"); + #else + ROS_ERROR("Open device failed"); + #endif + lidar_destory_device(odinDevice); + odinDevice = nullptr; + return; + } + + // 设置模式 + if (lidar_set_mode(odinDevice, type)) { + #ifdef ROS2 + RCLCPP_ERROR(rclcpp::get_logger("device_cb"), "Set mode failed"); + #else + ROS_ERROR("Set mode failed"); + #endif + lidar_close_device(odinDevice); + lidar_destory_device(odinDevice); + odinDevice = nullptr; + return; + } + + // 注册回调 + lidar_data_callback_info_t data_callback_info; + data_callback_info.data_callback = lidar_data_callback; + data_callback_info.user_data = &odinDevice; + + if (lidar_register_stream_callback(odinDevice, data_callback_info)) { + #ifdef ROS2 + RCLCPP_ERROR(rclcpp::get_logger("device_cb"), "Register callback failed"); + #else + ROS_ERROR("Register callback failed"); + #endif + lidar_close_device(odinDevice); + lidar_destory_device(odinDevice); + odinDevice = nullptr; + return; + } + + // 启动数据流 + if (lidar_start_stream(odinDevice, type)) { + #ifdef ROS2 + RCLCPP_ERROR(rclcpp::get_logger("device_cb"), "Start stream failed"); + #else + ROS_ERROR("Start stream failed"); + #endif + lidar_close_device(odinDevice); + lidar_destory_device(odinDevice); + odinDevice = nullptr; + return; + } + + // 根据配置激活数据流类型 + if (g_sendrgb) { + lidar_activate_stream_type(odinDevice, LIDAR_DT_RAW_RGB); + } + if (g_sendimu) { + lidar_activate_stream_type(odinDevice, LIDAR_DT_RAW_IMU); + } + if (g_sendodom) { + lidar_activate_stream_type(odinDevice, LIDAR_DT_SLAM_ODOMETRY); + } + if (g_senddtof) { + lidar_activate_stream_type(odinDevice, LIDAR_DT_RAW_DTOF); + } + if (g_sendcloudslam) { + lidar_activate_stream_type(odinDevice, LIDAR_DT_SLAM_CLOUD); + } + + deviceConnected = true; + #ifdef ROS2 + RCLCPP_INFO(rclcpp::get_logger("device_cb"), "Device ready and streams activated"); + #else + ROS_INFO("Device ready and streams activated"); + #endif + } else { + #ifdef ROS2 + RCLCPP_INFO(rclcpp::get_logger("device_cb"), "Device detaching..."); + #else + ROS_INFO("Device detaching..."); + #endif + + deviceConnected = false; + + if (odinDevice) { + lidar_stop_stream(odinDevice, LIDAR_MODE_SLAM); + lidar_unregister_stream_callback(odinDevice); + lidar_close_device(odinDevice); + lidar_destory_device(odinDevice); + odinDevice = nullptr; + } + } +} + +int main(int argc, char *argv[]) +{ + // ROS初始化 + #ifdef ROS2 + rclcpp::init(argc, argv); + auto node = std::make_shared("lydros_node"); + g_ros_object = std::make_shared(node); + #else + ros::init(argc, argv, "lydros_node"); + ros::NodeHandle nh; + g_ros_object = std::make_shared(nh); + #endif + + try { + std::string package_path = get_package_share_path("odin_ros_driver"); + std::string config_file = package_path + "/config/control_command.yaml"; + + // 创建 YAML 解析器 + odin_ros_driver::YamlParser parser(config_file); + + // 加载配置 + if (!parser.loadConfig()) { + #ifdef ROS2 + RCLCPP_ERROR(node->get_logger(), "Failed to load config file: %s", config_file.c_str()); + #else + ROS_ERROR("Failed to load config file: %s", config_file.c_str()); + #endif + return -1; + } + + // 获取键值映射 + auto keys = parser.getRegisterKeys(); + + // 打印配置 + parser.printConfig(); + + // 获取键值函数 + auto get_key_value = [&](const std::string& key_name, int default_value) -> int { + auto it = keys.find(key_name); + if (it != keys.end()) { + return it->second; + } + return default_value; + }; + + // 读取配置值到全局变量 + g_sendrgb = get_key_value("sendrgb", 1); + g_sendimu = get_key_value("sendimu", 1); + g_senddtof = get_key_value("senddtof", 1); + g_sendodom = get_key_value("sendodom", 1); + g_sendcloudslam = get_key_value("sendcloudslam", 0); + + // 设置日志级别 + lidar_log_set_level(LIDAR_LOG_INFO); + + // 初始化系统，启动USB监控 + if(lidar_system_init(lidar_device_callback)) { + #ifdef ROS2 + RCLCPP_ERROR(node->get_logger(), "Lidar system init failed"); + #else + ROS_ERROR("Lidar system init failed"); + #endif + return -1; + } + + // 等待设备连接（最长30秒） + #ifdef ROS2 + RCLCPP_INFO(node->get_logger(), "Waiting for device connection..."); + #else + ROS_INFO("Waiting for device connection..."); + #endif + + auto start = std::chrono::steady_clock::now(); + while (!deviceConnected) { + auto now = std::chrono::steady_clock::now(); + auto elapsed = std::chrono::duration_cast(now - start); + + if (elapsed.count() >= 30) { + #ifdef ROS2 + RCLCPP_ERROR(node->get_logger(), "No device connected after 30 seconds"); + #else + ROS_ERROR("No device connected after 30 seconds"); + #endif + lidar_system_deinit(); + return -1; + } + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + } + + } catch (const std::exception& e) { + #ifdef ROS2 + RCLCPP_ERROR(node->get_logger(), "Exception: %s", e.what()); + #else + ROS_ERROR("Exception: %s", e.what()); + #endif + lidar_system_deinit(); + return -1; + } + + // ROS主循环 + #ifdef ROS2 + rclcpp::spin(node); + rclcpp::shutdown(); + #else + ros::spin(); + ros::shutdown(); + #endif + + // 清理 + if (odinDevice) { + lidar_stop_stream(odinDevice, LIDAR_MODE_SLAM); + lidar_unregister_stream_callback(odinDevice); + lidar_close_device(odinDevice); + lidar_destory_device(odinDevice); + } + lidar_system_deinit(); + + return 0; +} diff --git a/src/yaml_parser.cpp b/src/yaml_parser.cpp new file mode 100644 index 0000000..ca6e9e1 --- /dev/null +++ b/src/yaml_parser.cpp @@ -0,0 +1,83 @@ +#include "yaml_parser.h" +#include +#include +#include +#include // 用于 std::transform + +namespace odin_ros_driver { + +// 使用一致的成员变量名 +YamlParser::YamlParser(const std::string& config_file) + : config_file_(config_file) {} // 这里使用 config_file_ + +bool YamlParser::loadConfig() { + try { + // 使用成员变量 config_file_ + std::cerr << "Loading config file: " << config_file_ << std::endl; + + // 检查文件是否存在 + if (!std::filesystem::exists(config_file_)) { + std::cerr << "Config file not found: " << config_file_ << std::endl; + return false; + } + + // 打印文件内容 + std::ifstream file(config_file_); + std::string content((std::istreambuf_iterator(file)), + std::istreambuf_iterator()); + std::cerr << "Config file content:\n" << content << "\n--- End of file ---" << std::endl; + + // 加载 YAML - 使用成员变量 config_file_ + YAML::Node config = YAML::LoadFile(config_file_); + + // 检查是否存在 register_keys 节点 + if (!config["register_keys"]) { + std::cerr << "Missing 'register_keys' section in config file" << std::endl; + return false; + } + + YAML::Node register_keys = config["register_keys"]; + register_keys_.clear(); + + // 打印键值对数量 + std::cerr << "Found " << register_keys.size() << " keys in config" << std::endl; + + for (YAML::const_iterator it = register_keys.begin(); it != register_keys.end(); ++it) { + std::string key = it->first.as(); + int value = it->second.as(); + + // 转换为小写 + std::transform(key.begin(), key.end(), key.begin(), + [](unsigned char c){ return std::tolower(c); }); + + register_keys_[key] = value; + std::cerr << "Loaded key: " << key << " = " << value << std::endl; + } + + return true; + } catch (const YAML::Exception& e) { + std::cerr << "YAML exception: " << e.what() << std::endl; + return false; + } catch (const std::exception& e) { + std::cerr << "Exception: " << e.what() << std::endl; + return false; + } +} + +const std::map& YamlParser::getRegisterKeys() const { + return register_keys_; +} + +void YamlParser::printConfig() const { + std::cerr << "Configuration Keys:" << std::endl; + if (register_keys_.empty()) { + std::cerr << " (empty)" << std::endl; + return; + } + + for (const auto& [key, value] : register_keys_) { + std::cerr << " " << key << ": " << value << std::endl; + } +} + +} // namespace odin_ros_driver \ No newline at end of file