i/OrbbecSDK_ROS2
1
0
Fork 0
mirror of https://github.com/orbbec/OrbbecSDK_ROS2.git synced 2026-09-12 03:00:20 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
8e7cad2bfa2c4a6ac4e779be99c64e72166043af
OrbbecSDK_ROS2/orbbec_camera/tools/ip_config_tool.cpp
T

663 lines
24 KiB
C++
Raw Blame History

#include "rclcpp/rclcpp.hpp"
#include <orbbec_camera/ob_camera_node_driver.h>
#include <orbbec_camera/utils.h>
#include <chrono>
#include <cstring>
#include <iostream>
#include <sstream>
#include <string>
#include <thread>
using namespace ob;
namespace {
constexpr int kFirmwareLogDrainDelaySec = 5;
void waitForFirmwareLogDrain(const rclcpp::Logger &logger) {
RCLCPP_INFO(logger, "Waiting %d seconds to keep firmware log alive...",
kFirmwareLogDrainDelaySec);
std::this_thread::sleep_for(std::chrono::seconds(kFirmwareLogDrainDelaySec));
}
bool isSdkLogEnabled(const std::string &log_level) {
return orbbec_camera::obLogSeverityFromString(log_level) != OBLogSeverity::OB_LOG_SEVERITY_OFF;
}
} // namespace
struct CliArgs {
enum class Operation {
NONE,
SET_IP,
FORCE_IP,
SET_DHCP_TIMEOUT,
};
bool help = false;
Operation operation = Operation::NONE;
bool dhcp = false;
bool dhcp_option_set = false;
bool persistent_ip = true;
bool persistent_ip_option_set = false;
int dhcp_assign_ip_timeout = -1;
bool dhcp_assign_ip_timeout_set = false;
std::string force_ip_mac;
std::string current_ip = "192.168.1.10";
int port = 8090;
std::string new_ip = "192.168.1.200";
std::string mask = "255.255.255.0";
std::string gateway = "192.168.1.1";
std::string sdk_log_level = "off";
};
bool parseIpString(const std::string &ip_str, uint8_t ip[4]) {
std::stringstream ss(ip_str);
std::string item;
int i = 0;
while (std::getline(ss, item, '.')) {
if (i >= 4) return false;
try {
int num = std::stoi(item);
if (num < 0 || num > 255) return false;
ip[i++] = static_cast<uint8_t>(num);
} catch (...) {
return false;
}
}
return i == 4;
}
bool parseBool(const std::string &value, bool &out) {
if (value == "true" || value == "1") {
out = true;
return true;
}
if (value == "false" || value == "0") {
out = false;
return true;
}
return false;
}
bool parseInt(const std::string &value, int &out) {
try {
size_t consumed = 0;
const int parsed = std::stoi(value, &consumed);
if (consumed != value.size()) {
return false;
}
out = parsed;
return true;
} catch (...) {
return false;
}
}
void printHelp() {
std::cout
<< "Usage:\n"
<< " ros2 run orbbec_camera ip_config_tool --\\\n"
<< " <set_ip|force_ip|set_dhcp_timeout> [options]\n"
<< " ros2 run orbbec_camera ip_config_tool -- set_ip\\\n"
<< " [--current_ip <ip>] [--port <port>] [--enable_dhcp <true|false>]\\\n"
<< " [--enable_persistent_ip <true|false>]\\\n"
<< " [--new_ip <ip>] [--mask <ip>] [--gateway <ip>]\n"
<< " ros2 run orbbec_camera ip_config_tool -- force_ip --force_ip_mac <mac>\\\n"
<< " [--enable_dhcp <true|false>] [--new_ip <ip>] [--mask <ip>] [--gateway <ip>]\n"
<< " ros2 run orbbec_camera ip_config_tool -- set_dhcp_timeout\\\n"
<< " [--current_ip <ip>] [--port <port>] --timeout <seconds>\n"
<< " [--sdk_log_level debug]\n"
<< " (legacy alias: set_device_ip)\n\n"
<< "Subcommands:\n"
<< " set_ip Configure DHCP and persistent IP by current device "
"address.\n"
<< " force_ip Force IP by MAC address.\n"
<< " set_dhcp_timeout Configure DHCP address assignment timeout.\n\n"
<< "Parameters:\n"
<< " --enable_dhcp <bool> DHCP flag for set-ip/force-ip "
"(default: false).\n"
<< " --enable_persistent_ip <bool>\n"
<< " Persistent IP flag for set-ip "
"(V2 independent flag, legacy requires mutual exclusion with DHCP).\n"
<< " --current_ip <ip> Current device IP for set-ip/set_dhcp_timeout "
"(default: 192.168.1.10).\n"
<< " --port <port> Device port for set-ip/set_dhcp_timeout "
"(default: 8090).\n"
<< " --new_ip <ip> Persistent IP for set-ip/force-ip "
"(default: 192.168.1.200).\n"
<< " --mask <ip> Subnet mask for set-ip/force-ip (default: 255.255.255.0).\n"
<< " --gateway <ip> Gateway for set-ip/force-ip (default: 192.168.1.1).\n"
<< " --force_ip_mac <mac> Target MAC for force-ip (required, e.g. "
"54:14:FD:06:07:DA).\n"
<< " --timeout <sec> DHCP timeout in seconds for set_dhcp_timeout.\n"
<< " --dhcp_assign_ip_timeout <sec>\n"
<< " Alias of --timeout.\n\n"
<< " --sdk_log_level LEVEL SDK file log level: debug/info/warn/error/fatal/off "
"(default: off).\n\n"
<< "Examples:\n"
<< "\n"
<< " [Set IP]\n"
<< " Persistent only: ros2 run orbbec_camera ip_config_tool -- \\\n"
<< " set_ip \\\n"
<< " --current_ip 192.168.1.10 \\\n"
<< " --enable_dhcp false \\\n"
<< " --enable_persistent_ip true \\\n"
<< " --new_ip 192.168.1.200 \\\n"
<< " --mask 255.255.255.0 \\\n"
<< " --gateway 192.168.1.1\n\n"
<< " DHCP only: ros2 run orbbec_camera ip_config_tool -- \\\n"
<< " set_ip \\\n"
<< " --current_ip 192.168.1.10 \\\n"
<< " --enable_dhcp true \\\n"
<< " --enable_persistent_ip false\n\n"
<< " Both enabled: ros2 run orbbec_camera ip_config_tool -- \\\n"
<< " set_ip \\\n"
<< " --current_ip 192.168.1.10 \\\n"
<< " --enable_dhcp true \\\n"
<< " --enable_persistent_ip true \\\n"
<< " --new_ip 192.168.1.200 \\\n"
<< " --mask 255.255.255.0 \\\n"
<< " --gateway 192.168.1.1\n"
<< "\n"
<< " [Force IP]\n"
<< " by MAC: ros2 run orbbec_camera ip_config_tool -- \\\n"
<< " force_ip \\\n"
<< " --force_ip_mac 54:14:FD:06:07:DA \\\n"
<< " --new_ip 192.168.1.200 \\\n"
<< " --mask 255.255.255.0 \\\n"
<< " --gateway 192.168.1.1\n"
<< "\n"
<< " [Set DHCP Timeout]\n"
<< " Timeout: ros2 run orbbec_camera ip_config_tool -- \\\n"
<< " set_dhcp_timeout \\\n"
<< " --current_ip 192.168.1.10 \\\n"
<< " --timeout 10\n"
<< " [SDK Log]\n"
<< " Debug: ros2 run orbbec_camera ip_config_tool -- \\\n"
<< " set_ip --current_ip 192.168.1.10 --enable_dhcp true "
"--enable_persistent_ip false \\\n"
<< " --sdk_log_level debug\n";
}
bool parseArgs(int argc, char **argv, CliArgs &args, std::string &error) {
for (int i = 1; i < argc; ++i) {
const std::string current = argv[i];
if (current == "-h" || current == "--help") {
args.help = true;
return true;
}
if (current == "set_ip" || current == "set-ip") {
if (args.operation != CliArgs::Operation::NONE) {
error = "Only one subcommand is allowed";
return false;
}
args.operation = CliArgs::Operation::SET_IP;
continue;
}
if (current == "force_ip" || current == "force-ip") {
if (args.operation != CliArgs::Operation::NONE) {
error = "Only one subcommand is allowed";
return false;
}
args.operation = CliArgs::Operation::FORCE_IP;
continue;
}
if (current == "set_dhcp_timeout" || current == "set-dhcp-timeout") {
if (args.operation != CliArgs::Operation::NONE) {
error = "Only one subcommand is allowed";
return false;
}
args.operation = CliArgs::Operation::SET_DHCP_TIMEOUT;
continue;
}
if (current.rfind("--enable_dhcp=", 0) == 0) {
if (!parseBool(current.substr(std::strlen("--enable_dhcp=")), args.dhcp)) {
error = "--enable_dhcp expects true/false";
return false;
}
args.dhcp_option_set = true;
continue;
}
if (current.rfind("--enable_persistent_ip=", 0) == 0) {
if (!parseBool(current.substr(std::strlen("--enable_persistent_ip=")), args.persistent_ip)) {
error = "--enable_persistent_ip expects true/false";
return false;
}
args.persistent_ip_option_set = true;
continue;
}
if (current == "--enable_persistent_ip") {
if (++i >= argc || !parseBool(argv[i], args.persistent_ip)) {
error = "--enable_persistent_ip expects true/false";
return false;
}
args.persistent_ip_option_set = true;
continue;
}
if (current == "--enable_dhcp") {
if (++i >= argc || !parseBool(argv[i], args.dhcp)) {
error = "--enable_dhcp expects true/false";
return false;
}
args.dhcp_option_set = true;
continue;
}
if (current.rfind("--current_ip=", 0) == 0) {
args.current_ip = current.substr(std::strlen("--current_ip="));
continue;
}
if (current == "--current_ip") {
if (++i >= argc) {
error = "--current_ip requires a value";
return false;
}
args.current_ip = argv[i];
continue;
}
if (current.rfind("--port=", 0) == 0) {
if (!parseInt(current.substr(std::strlen("--port=")), args.port)) {
error = "--port expects an integer";
return false;
}
continue;
}
if (current == "--port") {
if (++i >= argc || !parseInt(argv[i], args.port)) {
error = "--port expects an integer";
return false;
}
continue;
}
if (current.rfind("--new_ip=", 0) == 0) {
args.new_ip = current.substr(std::strlen("--new_ip="));
continue;
}
if (current == "--new_ip") {
if (++i >= argc) {
error = "--new_ip requires a value";
return false;
}
args.new_ip = argv[i];
continue;
}
if (current.rfind("--mask=", 0) == 0) {
args.mask = current.substr(std::strlen("--mask="));
continue;
}
if (current == "--mask") {
if (++i >= argc) {
error = "--mask requires a value";
return false;
}
args.mask = argv[i];
continue;
}
if (current.rfind("--gateway=", 0) == 0) {
args.gateway = current.substr(std::strlen("--gateway="));
continue;
}
if (current == "--gateway") {
if (++i >= argc) {
error = "--gateway requires a value";
return false;
}
args.gateway = argv[i];
continue;
}
if (current.rfind("--force_ip_mac=", 0) == 0) {
args.force_ip_mac = current.substr(std::strlen("--force_ip_mac="));
continue;
}
if (current == "--force_ip_mac") {
if (++i >= argc) {
error = "--force_ip_mac requires a value";
return false;
}
args.force_ip_mac = argv[i];
continue;
}
if (current.rfind("--timeout=", 0) == 0) {
if (!parseInt(current.substr(std::strlen("--timeout=")), args.dhcp_assign_ip_timeout)) {
error = "--timeout expects an integer";
return false;
}
args.dhcp_assign_ip_timeout_set = true;
continue;
}
if (current == "--timeout") {
if (++i >= argc || !parseInt(argv[i], args.dhcp_assign_ip_timeout)) {
error = "--timeout expects an integer";
return false;
}
args.dhcp_assign_ip_timeout_set = true;
continue;
}
if (current.rfind("--dhcp_assign_ip_timeout=", 0) == 0) {
if (!parseInt(current.substr(std::strlen("--dhcp_assign_ip_timeout=")),
args.dhcp_assign_ip_timeout)) {
error = "--dhcp_assign_ip_timeout expects an integer";
return false;
}
args.dhcp_assign_ip_timeout_set = true;
continue;
}
if (current == "--dhcp_assign_ip_timeout") {
if (++i >= argc || !parseInt(argv[i], args.dhcp_assign_ip_timeout)) {
error = "--dhcp_assign_ip_timeout expects an integer";
return false;
}
args.dhcp_assign_ip_timeout_set = true;
continue;
}
if (current.rfind("--sdk_log_level=", 0) == 0) {
args.sdk_log_level = current.substr(std::strlen("--sdk_log_level="));
continue;
}
if (current == "--sdk_log_level") {
if (++i >= argc) {
error = "--sdk_log_level requires a value";
return false;
}
args.sdk_log_level = argv[i];
continue;
}
error = "Unknown argument: " + current;
return false;
}
if (args.operation == CliArgs::Operation::NONE) {
error = "Missing subcommand. Use one of: set_ip, force_ip, set_dhcp_timeout";
return false;
}
if (args.operation != CliArgs::Operation::SET_IP && args.persistent_ip_option_set) {
error = "--enable_persistent_ip is only supported by set_ip";
return false;
}
if (args.operation == CliArgs::Operation::FORCE_IP && args.force_ip_mac.empty()) {
error = "force_ip requires --force_ip_mac <mac>";
return false;
}
if (args.operation == CliArgs::Operation::SET_DHCP_TIMEOUT && !args.dhcp_assign_ip_timeout_set) {
error = "set_dhcp_timeout requires --timeout <seconds>";
return false;
}
const auto log_severity = orbbec_camera::obLogSeverityFromString(args.sdk_log_level);
if (log_severity == OBLogSeverity::OB_LOG_SEVERITY_OFF && args.sdk_log_level != "off" &&
args.sdk_log_level != "none") {
error = "--sdk_log_level expects one of: debug, info, warn, error, fatal, off";
return false;
}
return true;
}
bool enableFirmwareLog(const rclcpp::Logger &logger, const std::shared_ptr<ob::Device> &device) {
try {
device->enableFirmwareLog(true);
RCLCPP_INFO(logger, "Firmware log enabled.");
return true;
} catch (const ob::Error &e) {
RCLCPP_WARN(logger, "Failed to enable firmware log: %s",
orbbec_camera::formatObErrorWithStatus(e).c_str());
} catch (const std::exception &e) {
RCLCPP_WARN(logger, "Failed to enable firmware log: %s", e.what());
}
return false;
}
int main(int argc, char **argv) {
CliArgs args;
std::string parse_error;
if (!parseArgs(argc, argv, args, parse_error)) {
std::cerr << "Argument error: " << parse_error << std::endl;
printHelp();
return 1;
}
if (args.help) {
printHelp();
return 0;
}
rclcpp::init(argc, argv);
auto logger = rclcpp::get_logger("ip_config_tool");
bool firmware_log_enabled = false;
try {
const auto sdk_log_path =
orbbec_camera::configureObSdkLoggerForTool("ip_config_tool", args.sdk_log_level);
if (!sdk_log_path.empty()) {
RCLCPP_INFO(logger, "SDK file log enabled: %s", sdk_log_path.c_str());
}
auto context = std::make_shared<ob::Context>();
if (args.operation == CliArgs::Operation::SET_IP) {
RCLCPP_INFO(logger, "Connecting to device %s:%d ...", args.current_ip.c_str(), args.port);
auto device = context->createNetDevice(args.current_ip.c_str(), args.port);
if (isSdkLogEnabled(args.sdk_log_level)) {
firmware_log_enabled = enableFirmwareLog(logger, device);
}
const bool v2_supported =
device->isPropertySupported(OB_STRUCT_DEVICE_IP_ADDR_CONFIG_V2, OB_PERMISSION_READ_WRITE);
if (v2_supported) {
// V2 supports enabling DHCP and persistent IP independently.
uint8_t address[4] = {0};
uint8_t mask[4] = {0};
uint8_t gateway[4] = {0};
if (args.persistent_ip && !parseIpString(args.new_ip, address)) {
RCLCPP_ERROR(logger, "Invalid new_ip format: %s", args.new_ip.c_str());
rclcpp::shutdown();
return 1;
}
if (args.persistent_ip && !parseIpString(args.mask, mask)) {
RCLCPP_ERROR(logger, "Invalid mask format: %s", args.mask.c_str());
rclcpp::shutdown();
return 1;
}
if (args.persistent_ip && !parseIpString(args.gateway, gateway)) {
RCLCPP_ERROR(logger, "Invalid gateway format: %s", args.gateway.c_str());
rclcpp::shutdown();
return 1;
}
OBNetIpConfigV2 ip_config_v2{};
uint32_t data_size = sizeof(ip_config_v2);
device->getStructuredData(OB_STRUCT_DEVICE_IP_ADDR_CONFIG_V2,
reinterpret_cast<uint8_t *>(&ip_config_v2), &data_size);
if (args.dhcp) {
ip_config_v2.flags = static_cast<uint16_t>(ip_config_v2.flags | OB_NET_IP_FLAG_DHCP);
} else {
ip_config_v2.flags = static_cast<uint16_t>(ip_config_v2.flags & ~OB_NET_IP_FLAG_DHCP);
}
if (args.persistent_ip) {
ip_config_v2.flags =
static_cast<uint16_t>(ip_config_v2.flags | OB_NET_IP_FLAG_PERSISTENT);
std::memcpy(ip_config_v2.address, address, sizeof(address));
std::memcpy(ip_config_v2.mask, mask, sizeof(mask));
std::memcpy(ip_config_v2.gateway, gateway, sizeof(gateway));
} else {
ip_config_v2.flags =
static_cast<uint16_t>(ip_config_v2.flags & ~OB_NET_IP_FLAG_PERSISTENT);
}
RCLCPP_INFO(logger, "Applying set-ip configuration with V2 property (1088)...");
device->setStructuredData(OB_STRUCT_DEVICE_IP_ADDR_CONFIG_V2,
reinterpret_cast<const uint8_t *>(&ip_config_v2),
sizeof(ip_config_v2));
RCLCPP_INFO(logger, "Set-ip configuration applied successfully (V2).");
RCLCPP_INFO(logger, "Set-ip target flags: %u.", ip_config_v2.flags);
RCLCPP_INFO(logger, "Set-ip target DHCP: %s.", args.dhcp ? "enabled" : "disabled");
RCLCPP_INFO(logger, "Set-ip target persistent IP: %s.",
args.persistent_ip ? "enabled" : "disabled");
RCLCPP_INFO(logger, "Set-ip target persistent IP: %d.%d.%d.%d", ip_config_v2.address[0],
ip_config_v2.address[1], ip_config_v2.address[2], ip_config_v2.address[3]);
RCLCPP_INFO(logger, "Set-ip target mask: %d.%d.%d.%d", ip_config_v2.mask[0],
ip_config_v2.mask[1], ip_config_v2.mask[2], ip_config_v2.mask[3]);
RCLCPP_INFO(logger, "Set-ip target gateway: %d.%d.%d.%d", ip_config_v2.gateway[0],
ip_config_v2.gateway[1], ip_config_v2.gateway[2], ip_config_v2.gateway[3]);
} else {
OBNetIpConfig ip_config{};
uint32_t data_size = sizeof(ip_config);
device->getStructuredData(OB_STRUCT_DEVICE_IP_ADDR_CONFIG,
reinterpret_cast<uint8_t *>(&ip_config), &data_size);
if (args.dhcp == args.persistent_ip) {
RCLCPP_ERROR(logger,
"Legacy IP config (1041) supports mutually exclusive DHCP and persistent "
"IP only. Use --enable_dhcp true --enable_persistent_ip false or "
"--enable_dhcp false --enable_persistent_ip true.");
rclcpp::shutdown();
return 1;
}
ip_config.dhcp = args.dhcp ? 1 : 0;
uint8_t address[4] = {0};
uint8_t mask[4] = {0};
uint8_t gateway[4] = {0};
if (args.persistent_ip && !parseIpString(args.new_ip, address)) {
RCLCPP_ERROR(logger, "Invalid new_ip format: %s", args.new_ip.c_str());
rclcpp::shutdown();
return 1;
}
if (args.persistent_ip && !parseIpString(args.mask, mask)) {
RCLCPP_ERROR(logger, "Invalid mask format: %s", args.mask.c_str());
rclcpp::shutdown();
return 1;
}
if (args.persistent_ip && !parseIpString(args.gateway, gateway)) {
RCLCPP_ERROR(logger, "Invalid gateway format: %s", args.gateway.c_str());
rclcpp::shutdown();
return 1;
}
if (args.persistent_ip) {
std::memcpy(ip_config.address, address, sizeof(address));
std::memcpy(ip_config.mask, mask, sizeof(mask));
std::memcpy(ip_config.gateway, gateway, sizeof(gateway));
}
RCLCPP_WARN(
logger,
"Device does not support IP config V2 (1088), fallback to legacy property (1041).");
RCLCPP_INFO(logger, "Applying set-ip configuration...");
device->setStructuredData(OB_STRUCT_DEVICE_IP_ADDR_CONFIG,
reinterpret_cast<const uint8_t *>(&ip_config), sizeof(ip_config));
RCLCPP_INFO(logger, "Set-ip configuration applied successfully.");
RCLCPP_INFO(logger, "Set-ip target mode: %s (dhcp=%u).",
ip_config.dhcp ? "DHCP" : "persistent", ip_config.dhcp);
RCLCPP_INFO(logger, "Set-ip target DHCP: %s.", args.dhcp ? "enabled" : "disabled");
RCLCPP_INFO(logger, "Set-ip target persistent IP: %s.",
args.persistent_ip ? "enabled" : "disabled");
RCLCPP_INFO(logger, "Set-ip target persistent IP: %d.%d.%d.%d", ip_config.address[0],
ip_config.address[1], ip_config.address[2], ip_config.address[3]);
RCLCPP_INFO(logger, "Set-ip target mask: %d.%d.%d.%d", ip_config.mask[0], ip_config.mask[1],
ip_config.mask[2], ip_config.mask[3]);
RCLCPP_INFO(logger, "Set-ip target gateway: %d.%d.%d.%d", ip_config.gateway[0],
ip_config.gateway[1], ip_config.gateway[2], ip_config.gateway[3]);
}
}
if (args.operation == CliArgs::Operation::FORCE_IP) {
OBNetIpConfig ip_config{};
ip_config.dhcp = args.dhcp ? 1 : 0;
if (!args.dhcp) {
if (!parseIpString(args.new_ip, ip_config.address)) {
RCLCPP_ERROR(logger, "Invalid new_ip format: %s", args.new_ip.c_str());
rclcpp::shutdown();
return 1;
}
if (!parseIpString(args.mask, ip_config.mask)) {
RCLCPP_ERROR(logger, "Invalid mask format: %s", args.mask.c_str());
rclcpp::shutdown();
return 1;
}
if (!parseIpString(args.gateway, ip_config.gateway)) {
RCLCPP_ERROR(logger, "Invalid gateway format: %s", args.gateway.c_str());
rclcpp::shutdown();
return 1;
}
}
RCLCPP_INFO(logger, "Applying force-ip to MAC %s ...", args.force_ip_mac.c_str());
if (context->forceIp(args.force_ip_mac.c_str(), ip_config)) {
RCLCPP_INFO(logger, "Force-ip operation applied successfully.");
std::this_thread::sleep_for(std::chrono::seconds(5));
if (args.dhcp) {
RCLCPP_INFO(logger, "Force-ip target mode: DHCP.");
} else {
RCLCPP_INFO(logger, "Force-ip target persistent IP: %s", args.new_ip.c_str());
RCLCPP_INFO(logger, "Force-ip target mask: %s", args.mask.c_str());
RCLCPP_INFO(logger, "Force-ip target gateway: %s", args.gateway.c_str());
}
} else {
RCLCPP_ERROR(logger, "Force-ip failed (SDK returned false).");
rclcpp::shutdown();
return 1;
}
}
if (args.operation == CliArgs::Operation::SET_DHCP_TIMEOUT) {
RCLCPP_INFO(logger, "Connecting to device %s:%d ...", args.current_ip.c_str(), args.port);
auto device = context->createNetDevice(args.current_ip.c_str(), args.port);
if (isSdkLogEnabled(args.sdk_log_level)) {
firmware_log_enabled = enableFirmwareLog(logger, device);
}
if (!device->isPropertySupported(OB_PROP_DHCP_ASSIGN_IP_TIMEOUT_INT, OB_PERMISSION_WRITE)) {
RCLCPP_ERROR(logger, "Current device or firmware does not support DHCP assign IP timeout");
rclcpp::shutdown();
return 1;
}
auto range = device->getIntPropertyRange(OB_PROP_DHCP_ASSIGN_IP_TIMEOUT_INT);
if (args.dhcp_assign_ip_timeout < range.min || args.dhcp_assign_ip_timeout > range.max) {
RCLCPP_ERROR(logger, "Timeout %d is out of range [%d, %d]", args.dhcp_assign_ip_timeout,
range.min, range.max);
rclcpp::shutdown();
return 1;
}
device->setIntProperty(OB_PROP_DHCP_ASSIGN_IP_TIMEOUT_INT, args.dhcp_assign_ip_timeout);
const int current_timeout = device->getIntProperty(OB_PROP_DHCP_ASSIGN_IP_TIMEOUT_INT);
RCLCPP_INFO(logger, "DHCP assign IP timeout applied successfully: %d second(s)",
current_timeout);
}
if (firmware_log_enabled) {
waitForFirmwareLogDrain(logger);
}
} catch (ob::Error &e) {
RCLCPP_ERROR(logger, "ip_config_tool: %s", orbbec_camera::formatObErrorWithStatus(e).c_str());
rclcpp::shutdown();
return 1;
} catch (const std::exception &e) {
RCLCPP_ERROR(logger, "ip_config_tool: %s", e.what());
rclcpp::shutdown();
return 1;
} catch (...) {
RCLCPP_ERROR(logger, "ip_config_tool: unknown error");
rclcpp::shutdown();
return 1;
}
rclcpp::shutdown();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink