update

include/ixsync.hpp

@@ -18,30 +18,66 @@ using namespace std;
 
 typedef function<void(XsyncTimecode_t *timecode_msg)>                     xsync_on_timecode_msg_t;
 typedef function<void(uint32_t recordSig, XsyncTimecode_t *timecode_msg)> xsync_on_record_sig_change_msg_t;
+typedef function<void(string targetIp, bool state)>                       xsync_on_connect_state_change_t;
 typedef function<void(xysnc_camera_sync_data_t *timecode_msg)>            xsync_on_camera_sync_msg_t;
 
+typedef struct {
+  bool placeholder;
+} xsync_config_t;
+
 class IXsync {
  public:
   virtual ~IXsync() {}
 
  public:
-  /***********************************************************************************************
-   *                                          设备基本操作                                         *
-   ***********************************************************************************************/
+  virtual xs_error_code_t initialize(xsync_config_t *config) = 0;
+
+  virtual bool   ping()            = 0;
+  virtual bool   getConnectState() = 0;
+  virtual string getDeviceIp()     = 0;
+
+  /*******************************************************************************
+   *                                  网络配置                                   *
+   *******************************************************************************/
+
+  /**
+   * @brief
+   *    注意事项:
+   *        1. 网络配置，需要在设备重启后生效
+   *        2. 设备软重启可以调用reboot方法
+   *        3. 只有网络配置是掉电不丢失的，其他配置均掉电丢失
+   */
+
+  // virtual xs_error_code_t NetworkConfig_setMode(NetworkMode_t mode)  = 0;
+  // virtual xs_error_code_t NetworkConfig_getMode(NetworkMode_t &mode) = 0;
 
-  virtual xs_error_code_t changeXsyncIp(string xsync_ip) = 0;
-  virtual bool            ping()                         = 0;
+  // virtual xs_error_code_t NetworkConfigStaticIpMode_setIp(string ip)  = 0;
+  // virtual xs_error_code_t NetworkConfigStaticIpMode_getIp(string &ip) = 0;
 
-  virtual void registerOnTimecodeMsgCallback(xsync_on_timecode_msg_t cb)                 = 0;
-  virtual void registerOnCameraSyncMsgCallback(xsync_on_camera_sync_msg_t cb)            = 0;
-  virtual void registerOnRecordSigChangeMsgCallback(xsync_on_record_sig_change_msg_t cb) = 0;
+  // virtual xs_error_code_t NetworkConfigStaticIpMode_setMask(string mask)  = 0;
+  // virtual xs_error_code_t NetworkConfigStaticIpMode_getMask(string &mask) = 0;
 
-  virtual xs_error_code_t generatorNewMac()                                           = 0;
-  virtual xs_error_code_t factoryReset()                                              = 0;
-  virtual xs_error_code_t reboot()                                                    = 0;
-  virtual xs_error_code_t changeNetworkConfig(string ip, string mask, string gateway) = 0;
-  virtual xs_error_code_t readSn(string &sn)                                          = 0;
-  virtual xs_error_code_t readMac(string &mac)                                        = 0;
+  // virtual xs_error_code_t NetworkConfigStaticIpMode_setGateway(string gateway)  = 0;
+  // virtual xs_error_code_t NetworkConfigStaticIpMode_getGateway(string &gateway) = 0;
+
+  /*******************************************************************************
+   *                              事件回调函数注册                               *
+   *******************************************************************************/
+  virtual void registerOnTimecodeMsgCallback(xsync_on_timecode_msg_t cb)                 = 0;  // timecode 回调
+  virtual void registerOnCameraSyncMsgCallback(xsync_on_camera_sync_msg_t cb)            = 0;  // 相机同步包 回调
+  virtual void registerOnRecordSigChangeMsgCallback(xsync_on_record_sig_change_msg_t cb) = 0;  // 录制信号变化 回调
+  virtual void registerOnConnectStateChangeCallback(xsync_on_connect_state_change_t cb)  = 0;  // 连接状态变化 回调
+
+  /*******************************************************************************
+   *                                设备基本操作                                 *
+   *******************************************************************************/
+  virtual xs_error_code_t generatorNewMac()    = 0;
+  virtual xs_error_code_t factoryReset()       = 0;
+  virtual xs_error_code_t reboot()             = 0;
+  virtual xs_error_code_t readSn(string &sn)   = 0;
+  virtual xs_error_code_t readMac(string &mac) = 0;
+
+  // virtual xs_error_code_t changeNetworkConfig(string ip, string mask, string gateway) = 0;
 
  public:
   virtual xs_error_code_t reg_write(uint32_t regadd, uint32_t regvalue, uint32_t &regbackvalue, int32_t overtime_ms = 100) = 0;
@@ -199,35 +235,35 @@ class IXsync {
    * TimeCode启动，外部TTL触发启动三种方式。通过RecordSigGenerator_setContrlMode可以设置。
    *
    * 手动控制:
-   * 
+   *
    *    如果是手动启动，先通过RecordSigGenerator_setContrlMode将模式配置成CONTROLMODE_MANUAL_TRIGGER，
    * 然后直接调用下面两个方法即可
    *      RecordSigGenerator_manualStart
    *      RecordSigGenerator_manualStop
    *
-   * 
+   *
    * Timecode控制:
-   * 
+   *
    *    如果是Timecode控制启动，先通过RecordSigGenerator_setContrlMode将模式配置成CONTROLMODE_TIMECODE_TRIGGER。
    * 然后可以调用下面几个方法进行配置即可。可通过RecordSigGenerator_setTimecodeCtrlFlag方法，只使能Timecode自动控制
    * 启动，或者只使能Timecode自动控制停止。
    *          RecordSigGenerator_setAutoStartTimecode :配置自动启动的时间点
    *          RecordSigGenerator_setAutoStopTimecode  :配置自动停止的时间点
    *          RecordSigGenerator_setTimecodeCtrlFlag  :配置是否使能自动启动，或者自动停止，默认配置是二者都使能的。
-   * 
+   *
    * 外部TTL控制:
-   * 
+   *
    *    如果是外部TTL触发启动，先通过RecordSigGenerator_setContrlMode将模式配置成CONTROLMODE_EXTERNALTTL_TRIGGER。
    * 然后调用下面几个方法进行配置。
    *          RecordSigGenerator_setExternalTTLTriggerSrc      : 配置外部TTL触发源（输入范围INPUT_IF_TTL1->INPUT_IF_TTL4）
    *          RecordSigGenerator_setExternalTTLTriggerPolarity : 配置触发电平(0:低电平，1:高电平)
-   * 
-   * 
+   *
+   *
    * 该模块输出的拍摄曝光信号，可以通过下面两个方法，设置曝光时间，曝光偏移时间。
    *        RecordSigGenerator_setRecordExposureTime
    *        RecordSigGenerator_setRecordExposureOffsetTime
-   * 
-   * 
+   *
+   *
    */
 
   virtual xs_error_code_t RecordSigGenerator_setContrlMode(ControlMode_t mode)                            = 0;
@@ -255,22 +291,10 @@ class IXsync {
    *                                          输出组件                                            *
    ***********************************************************************************************/
 
-
-
-
-
-
-
-
-
-
-
-
-
   /**
    * @brief 输入组件一共有4组，TTL，Timecode，Genlock，网口，其中只有TTL输出(包含隔离输出)需要对齐进行配置。
-   * 
-   * 
+   *
+   *
    *  TTL输出组件
    *      信号源选择范围:
    *         SIGNAL_LOGIC0
@@ -284,13 +308,13 @@ class IXsync {
    *         SIGNAL_SYS_TIMECODE_FREQ_OUTPUT
    *         SIGNAL_BUSINESS_RECORD_SIG
    *         SIGNAL_BUSINESS_RECORD_EXPOSURE_SIG
-   * 
+   *
    *      分频倍频:
    *         当信号源是 SIGNAL_BUSINESS_RECORD_SIG 或者 SIGNAL_BUSINESS_RECORD_EXPOSURE_SIG 分频倍频不启作用，
    *      直接输出原始信号。当信号源是其他信号源时，分频倍频起作用。分频输入参数为0时，为不分频，1时，为2分频。倍频
    *      输入参数为0时，为不倍频，1时，为2倍频。
-   * 
-   * 
+   *
+   *
    */
 
   virtual xs_error_code_t TTLOutputModule1_setSrcSigType(SignalType_t source)     = 0;

include/xsync_errcode.hpp

@@ -19,7 +19,7 @@ typedef enum {
   kxs_ec_send_fail                  = 4,
   kxs_ec_receive_fail               = 5,
   kxs_ec_setsockopt_rx_timeout_fail = 6,
-  kxs_ec_lose_connect               = 7,
+  kxs_ec_device_offline               = 7,
   kxs_ec_param_error                = 8,
 } xs_error_code_t;
 
@@ -39,8 +39,8 @@ static inline const char* xs_error_code_2_str(xs_error_code_t ecode) {
       return "receive fail";
     case kxs_ec_setsockopt_rx_timeout_fail:
       return "setsockopt rx timeout fail";
-    case kxs_ec_lose_connect:
-      return "lose connect";
+    case kxs_ec_device_offline:
+      return "device offline";
     case kxs_ec_param_error:
       return "param error";
     default:

include/xsync_utils.hpp

@@ -21,4 +21,6 @@ uint32_t        ipToUint32(const std::string &ipAddress, bool &suc);
 XsyncTimecode_t timecode64ToXsyncTimeCode(Timecode64_t tc64);
 Timecode64_t    timecodeTo64(XsyncTimecode_t tc);
 
+int64_t Xsync_GetTicket();
+
 };  // namespace xsync

include/xsync_v2.hpp

@@ -10,6 +10,7 @@
 #include <sstream>
 #include <string>
 #include <vector>
+#include <thread>
 
 //
 #include "i_xsync_udp.hpp"
@@ -18,7 +19,7 @@
 namespace xsync {
 using namespace std;
 
-void    XsyncInit(I_XSUDPFactory *xsync_udp_factory, string xsyncIp);
+void    XsyncInit(I_XSUDPFactory *xsync_udp_factory);
 IXsync *XsyncIns();
 
 }  // namespace xsync

include/xsync_v2_sig_type.hpp

@@ -173,4 +173,13 @@ TriggerEdge_t Str2TriggerEdge(string edge);
 string        TriggerEdge2Str(TriggerEdge_t edge);
 list<string>  TriggerEdgeStrSet();
 
+/*******************************************************************************
+ *                                  网络配置                                   *
+ *******************************************************************************/
+
+typedef enum {
+  STATIC_IP_MODE = 0,
+  DHCP_MODE      = 1,
+} NetworkMode_t;
+
 }  // namespace xsync

src/xsync_utils.cpp

@@ -1,4 +1,9 @@
 #include "xsync_utils.hpp"
+
+#include <chrono>
+#include <ctime>
+#include <iostream>
+
 namespace xsync {
 uint32_t ipToUint32(const std::string &ipAddress, bool &suc) {
   uint32_t           result = 0;
@@ -67,4 +72,9 @@ Timecode64_t timecodeTo64(XsyncTimecode_t tc) {
   return tc64;
 }
 
+int64_t Xsync_GetTicket() {
+  auto now = std::chrono::steady_clock::now();
+  return now.time_since_epoch().count();
+}
+
 };  // namespace xsync

src/xsync_v2.cpp

@@ -4,6 +4,7 @@
 
 #include <map>
 
+#include "../src/logger.hpp"
 #include "xsync_errcode.hpp"
 #include "xsync_regs.hpp"
 #include "xsync_utils.hpp"
@@ -46,11 +47,12 @@ using namespace std;
     return kxs_ec_success;                \
   }
 
+I_XSUDPFactory *g_xsync_udp_factory = nullptr;
+
 class Xsync : public IXsync {
  private:
   /* data */
 
-  I_XSUDPFactory     *m_xsync_udp_factory              = nullptr;
   shared_ptr<I_XSUDP> m_xsync_reg_udp                  = nullptr;
   shared_ptr<I_XSUDP> m_xsync_timecode_udp_listener    = nullptr;
   shared_ptr<I_XSUDP> m_xsync_camera_sync_udp_listener = nullptr;
@@ -61,33 +63,150 @@ class Xsync : public IXsync {
   xsync_on_camera_sync_msg_t       m_on_camera_sync_msg_cb       = nullptr;
   xsync_on_timecode_msg_t          m_on_timecode_msg_cb          = nullptr;
   xsync_on_record_sig_change_msg_t m_on_record_sig_change_msg_cb = nullptr;
+  xsync_on_connect_state_change_t  m_on_connect_state_change_cb  = nullptr;
 
   int                  txpacket_index = 0;
   uint8_t              m_xync_cmd_rxdata_cache[2560];
   std::recursive_mutex lock_;
+  std::recursive_mutex connectStatelock_;
+
+  // <thread>
+  unique_ptr<thread> device_state_monitor_thread;
+  bool               destoryflag              = false;
+  int64_t            m_last_receive_packet_tp = 0;
+
+ private:
+  void _setNetworkState(bool connected, string ip) {
+    lock_guard<recursive_mutex> lock(connectStatelock_);
+    m_is_connected = connected;
+    m_xsync_ip     = ip;
+    if (m_on_connect_state_change_cb) m_on_connect_state_change_cb(m_xsync_ip, m_is_connected);
+  }
+
+  string _getXsyncIp() {
+    lock_guard<recursive_mutex> lock(connectStatelock_);
+    return m_xsync_ip;
+  }
+
+  bool _getConnectState() {
+    lock_guard<recursive_mutex> lock(connectStatelock_);
+    return m_is_connected;
+  }
 
  public:
   static Xsync &Ins();
 
-  Xsync(/* args */);
-  virtual ~Xsync() {}
-
-  void initialize(I_XSUDPFactory *xsync_udp_factory);
+  Xsync(/* args */) {}
+  virtual ~Xsync() {
+    destoryflag = true;
+    if (device_state_monitor_thread) device_state_monitor_thread->join();
+
+    if (m_xsync_timecode_udp_listener) m_xsync_timecode_udp_listener->stopReceive();
+    if (m_xsync_camera_sync_udp_listener) m_xsync_camera_sync_udp_listener->stopReceive();
+    if (m_xsync_reg_udp) m_xsync_reg_udp->stopReceive();
+  }
+
+  virtual xs_error_code_t initialize(xsync_config_t *config) override {
+    lock_guard<recursive_mutex> lock(lock_);
+    xs_error_code_t             ecode = kxs_ec_success;
+    shared_ptr<I_XSUDP>         xsync_reg_udp;
+    shared_ptr<I_XSUDP>         xsync_timecode_udp_listener;
+    shared_ptr<I_XSUDP>         xsync_camera_sync_udp_listener;
+
+    // 寄存器读写UDP
+    xsync_reg_udp = g_xsync_udp_factory->createXSUDP();
+    ecode         = xsync_reg_udp->initialize("0.0.0.0", IFLYTOP_XSYNC_SERVICE_PC_PORT);
+    if (ecode != kxs_ec_success) goto err;
+
+    // TIMECODE上报消息接收UDP
+    xsync_timecode_udp_listener = g_xsync_udp_factory->createXSUDP();
+    ecode                       = xsync_timecode_udp_listener->initialize("0.0.0.0", IFLYTOP_XSYNC_TIMECODE_REPORT_PC_PORT);
+    if (ecode != kxs_ec_success) goto err;
+    ecode = xsync_timecode_udp_listener->startReceive([this](XsyncNetAdd &from, uint8_t *data, size_t length) {
+      iflytop_xsync_event_report_packet_t *packet = (iflytop_xsync_event_report_packet_t *)data;
+
+      if (!_getConnectState()) {
+        m_last_receive_packet_tp = Xsync_GetTicket();
+        _setNetworkState(true, from.ip);
+      }
+
+      if (_getConnectState() && _getXsyncIp() != from.ip) {
+        return;
+      }
+
+      m_last_receive_packet_tp = Xsync_GetTicket();
+
+      if (packet->eventid == ktimecode_report_event) {
+        Timecode64_t tc64;
+        tc64.tc0                 = packet->data[0];
+        tc64.tc1                 = packet->data[1];
+        XsyncTimecode_t timecode = timecode64ToXsyncTimeCode(tc64);
+        if (m_on_timecode_msg_cb) m_on_timecode_msg_cb(&timecode);
+      } else if (packet->eventid == kxsync_work_state_report_event) {
+        // 信号发生器状态改变
+        Timecode64_t tc64;
+        tc64.tc0                 = packet->data[1];
+        tc64.tc1                 = packet->data[2];
+        XsyncTimecode_t timecode = timecode64ToXsyncTimeCode(tc64);
+
+        if (m_on_record_sig_change_msg_cb) m_on_record_sig_change_msg_cb(packet->data[0], &timecode);
+      }
+    });
+    if (ecode != kxs_ec_success) goto err;
+
+#if 1
+    // 相机同步包
+    xsync_camera_sync_udp_listener = g_xsync_udp_factory->createXSUDP();
+    ecode                          = xsync_camera_sync_udp_listener->initialize("0.0.0.0", IFLYTOP_XSYNC_CAMERA_SYNC_PACKET_PC_PORT);
+    if (ecode != kxs_ec_success) goto err;
+    ecode = xsync_camera_sync_udp_listener->startReceive([this](XsyncNetAdd &from, uint8_t *data, size_t length) { parseCameraSyncMsgAndReport(from, data, length); });
+    if (ecode != kxs_ec_success) goto err;
+#endif
+
+    m_xsync_timecode_udp_listener    = xsync_timecode_udp_listener;
+    m_xsync_camera_sync_udp_listener = xsync_camera_sync_udp_listener;
+    m_xsync_reg_udp                  = xsync_reg_udp;
+
+    // 设备枚举线程
+    device_state_monitor_thread.reset(new thread([this]() {
+      while (!destoryflag) {
+        int32_t has_not_receive_packet_time_s = (Xsync_GetTicket() - m_last_receive_packet_tp) / 1000 / 1000 / 1000;
+        // ZLOGI(TAG, "%lld ", has_not_receive_packet_time_s);
+        if (m_is_connected && (has_not_receive_packet_time_s) > 5) {
+          _setNetworkState(false, "");
+        }
+        this_thread::sleep_for(chrono::seconds(1));
+      }
+      return;
+    }));
+
+    return kxs_ec_success;
+  err:
+    if (xsync_timecode_udp_listener) xsync_timecode_udp_listener->stopReceive();
+    if (xsync_camera_sync_udp_listener) xsync_camera_sync_udp_listener->stopReceive();
+    return ecode;
+  }
 
-  xs_error_code_t connect(string xsync_ip);
-  xs_error_code_t disConnect();
+  virtual bool ping() override {
+    uint32_t        readbak;
+    xs_error_code_t ecode = reg_read(reg::kproduct_type_id, readbak, 10);
+    if (ecode != kxs_ec_success) {
+      return false;
+    }
+    return true;
+  }
 
-  virtual xs_error_code_t changeXsyncIp(string xsync_ip) override;
-  virtual bool            ping() override;
+  virtual bool   getConnectState() override { return _getConnectState(); }
+  virtual string getDeviceIp() override { return _getXsyncIp(); }
 
-  virtual void registerOnTimecodeMsgCallback(xsync_on_timecode_msg_t cb) override;
-  virtual void registerOnCameraSyncMsgCallback(xsync_on_camera_sync_msg_t cb) override;
-  virtual void registerOnRecordSigChangeMsgCallback(xsync_on_record_sig_change_msg_t cb) override;
+  virtual void registerOnTimecodeMsgCallback(xsync_on_timecode_msg_t cb) override { m_on_timecode_msg_cb = cb; }
+  virtual void registerOnCameraSyncMsgCallback(xsync_on_camera_sync_msg_t cb) override { m_on_camera_sync_msg_cb = cb; }
+  virtual void registerOnRecordSigChangeMsgCallback(xsync_on_record_sig_change_msg_t cb) override { m_on_record_sig_change_msg_cb = cb; }
+  virtual void registerOnConnectStateChangeCallback(xsync_on_connect_state_change_t cb) override { m_on_connect_state_change_cb = cb; };
 
   virtual xs_error_code_t generatorNewMac() override;
   virtual xs_error_code_t factoryReset() override;
   virtual xs_error_code_t reboot() override;
-  virtual xs_error_code_t changeNetworkConfig(string ip, string mask, string gateway) override;
   virtual xs_error_code_t readSn(string &sn) override;
   virtual xs_error_code_t readMac(string &mac) override;
 
@@ -229,101 +348,11 @@ class Xsync : public IXsync {
 /*******************************************************************************
  *                                    Xsync                                    *
  *******************************************************************************/
-Xsync::Xsync(/* args */) {}
 
 Xsync &Xsync::Ins() {
   static Xsync xsync;
   return xsync;
 }
-void Xsync::initialize(I_XSUDPFactory *xsync_udp_factory) { m_xsync_udp_factory = xsync_udp_factory; }
-
-xs_error_code_t Xsync::changeXsyncIp(string xsync_ip) {
-  disConnect();
-  return connect(xsync_ip);
-}
-bool Xsync::ping() {
-  uint32_t        readbak;
-  xs_error_code_t ecode = reg_read(reg::kproduct_type_id, readbak, 10);
-  if (ecode != kxs_ec_success) {
-    return false;
-  }
-  return true;
-}
-
-xs_error_code_t Xsync::connect(string xsync_ip) {
-  lock_guard<recursive_mutex> lock(lock_);
-
-  m_xsync_ip = xsync_ip;
-  disConnect();
-  /**
-   * @brief 创建 m_xsync_reg_udp
-   */
-
-  xs_error_code_t ecode = kxs_ec_success;
-
-  auto xsync_reg_udp = m_xsync_udp_factory->createXSUDP();
-  ecode              = xsync_reg_udp->initialize("0.0.0.0", IFLYTOP_XSYNC_SERVICE_PC_PORT);
-  if (ecode != kxs_ec_success) {
-    return ecode;
-  }
-  /**
-   * @brief 创建 m_xsync_timecode_udp_listener
-   */
-  auto xsync_timecode_udp_listener = m_xsync_udp_factory->createXSUDP();
-
-  ecode = xsync_timecode_udp_listener->initialize("0.0.0.0", IFLYTOP_XSYNC_TIMECODE_REPORT_PC_PORT);
-  if (ecode != kxs_ec_success) {
-    return ecode;
-  }
-  ecode = xsync_timecode_udp_listener->startReceive([this](XsyncNetAdd &from, uint8_t *data, size_t length) { parseTimecodeMsgAndReport(from, data, length); });
-  if (ecode != kxs_ec_success) {
-    return ecode;
-  }
-
-  /**
-   * @brief 创建 m_xsync_camera_sync_udp_listener
-   */
-  auto xsync_camera_sync_udp_listener = m_xsync_udp_factory->createXSUDP();
-
-  ecode = xsync_camera_sync_udp_listener->initialize("0.0.0.0", IFLYTOP_XSYNC_CAMERA_SYNC_PACKET_PC_PORT);
-  if (ecode != kxs_ec_success) {
-    return ecode;
-  }
-  ecode = xsync_camera_sync_udp_listener->startReceive([this](XsyncNetAdd &from, uint8_t *data, size_t length) { parseCameraSyncMsgAndReport(from, data, length); });
-  if (ecode != kxs_ec_success) {
-    return ecode;
-  }
-
-  m_xsync_reg_udp                  = xsync_reg_udp;
-  m_xsync_timecode_udp_listener    = xsync_timecode_udp_listener;
-  m_xsync_camera_sync_udp_listener = xsync_camera_sync_udp_listener;
-
-  return ecode;
-}
-xs_error_code_t Xsync::disConnect() {
-  lock_guard<recursive_mutex> lock(lock_);
-
-  if (m_xsync_reg_udp != nullptr) {
-    m_xsync_reg_udp->stopReceive();
-    m_xsync_reg_udp = nullptr;
-  }
-
-  if (m_xsync_timecode_udp_listener != nullptr) {
-    m_xsync_timecode_udp_listener->stopReceive();
-    m_xsync_timecode_udp_listener = nullptr;
-  }
-
-  if (m_xsync_camera_sync_udp_listener != nullptr) {
-    m_xsync_camera_sync_udp_listener->stopReceive();
-    m_xsync_camera_sync_udp_listener = nullptr;
-  }
-
-  return kxs_ec_success;
-}
-
-void Xsync::registerOnTimecodeMsgCallback(xsync_on_timecode_msg_t cb) { m_on_timecode_msg_cb = cb; }
-void Xsync::registerOnCameraSyncMsgCallback(xsync_on_camera_sync_msg_t cb) { m_on_camera_sync_msg_cb = cb; }
-void Xsync::registerOnRecordSigChangeMsgCallback(xsync_on_record_sig_change_msg_t cb) { m_on_record_sig_change_msg_cb = cb; }
 
 xs_error_code_t Xsync::readSn(string &sn) {
   sn = "X1001000000000";
@@ -346,12 +375,16 @@ xs_error_code_t Xsync::readMac(string &mac) {
 
 xs_error_code_t Xsync::xsync_send_cmd_block(iflytop_xsync_packet_header_t *cmd, iflytop_xsync_packet_header_t *rx_data, int32_t buffersize, int32_t overtime_ms) {
   lock_guard<recursive_mutex> lock(lock_);
-  if (!m_xsync_reg_udp) return kxs_ec_lose_connect;
+
+  string xsyncip = _getXsyncIp();
   m_xsync_reg_udp->clearRxBuffer();
 
+  if (!m_xsync_reg_udp) return kxs_ec_device_offline;
+  if (xsyncip.empty()) return kxs_ec_device_offline;
+
   cmd->index = txpacket_index++;
 
-  XsyncNetAdd     toadd = {m_xsync_ip, IFLYTOP_XSYNC_SERVICE_XSYNC_PORT};
+  XsyncNetAdd     toadd = {xsyncip, IFLYTOP_XSYNC_SERVICE_XSYNC_PORT};
   xs_error_code_t ecode =  //
       m_xsync_reg_udp->sendto(toadd, (const char *)cmd, sizeof(iflytop_xsync_packet_header_t) + cmd->ndata * 4, nullptr);
   if (ecode != kxs_ec_success) {
@@ -525,24 +558,7 @@ xs_error_code_t Xsync::readfreq(uint32_t reg, float &freqfloat) {
   return kxs_ec_success;
 }
 
-void Xsync::parseTimecodeMsgAndReport(XsyncNetAdd &from, uint8_t *data, size_t length) {
-  iflytop_xsync_event_report_packet_t *packet = (iflytop_xsync_event_report_packet_t *)data;
-  if (packet->eventid == ktimecode_report_event) {
-    Timecode64_t tc64;
-    tc64.tc0                 = packet->data[0];
-    tc64.tc1                 = packet->data[1];
-    XsyncTimecode_t timecode = timecode64ToXsyncTimeCode(tc64);
-    if (m_on_timecode_msg_cb) m_on_timecode_msg_cb(&timecode);
-  } else if (packet->eventid == kxsync_work_state_report_event) {
-    // 信号发生器状态改变
-    Timecode64_t tc64;
-    tc64.tc0                 = packet->data[1];
-    tc64.tc1                 = packet->data[2];
-    XsyncTimecode_t timecode = timecode64ToXsyncTimeCode(tc64);
-
-    if (m_on_record_sig_change_msg_cb) m_on_record_sig_change_msg_cb(packet->data[0], &timecode);
-  }
-}
+void Xsync::parseTimecodeMsgAndReport(XsyncNetAdd &from, uint8_t *data, size_t length) {}
 void Xsync::parseCameraSyncMsgAndReport(XsyncNetAdd &from, uint8_t *data, size_t length) {
   uint32_t count = 0;
 
@@ -563,6 +579,7 @@ xs_error_code_t Xsync::generatorNewMac() { return doaction(xsync_stm32_action_ge
 xs_error_code_t Xsync::factoryReset() { return doaction(xsync_stm32_action_factory_reset, 0, nullptr, 1000); }
 xs_error_code_t Xsync::reboot() { return doaction(xsync_stm32_action_reboot, 0, nullptr); }
 xs_error_code_t Xsync::storageConfig() { return doaction(xsync_stm32_action_storage_cfg, 0, nullptr, 1000); }
+#if 0
 xs_error_code_t Xsync::changeNetworkConfig(string ip, string mask, string gateway) {
   uint32_t        ip32      = 0;
   uint32_t        mask32    = 0;
@@ -591,6 +608,7 @@ xs_error_code_t Xsync::changeNetworkConfig(string ip, string mask, string gatewa
 
   return kxs_ec_success;
 }
+#endif
 
 xs_error_code_t Xsync::doaction(uint32_t action, uint32_t actionval, uint32_t *ackreturn, int32_t overtime_ms) {
   //
@@ -953,10 +971,6 @@ xs_error_code_t Xsync::RecordSigGenerator_readTimecodeSnapshot(XsyncTimecode_t &
 }
 
 namespace xsync {
-
-void XsyncInit(I_XSUDPFactory *xsync_udp_factory, string xsyncIp) {
-  Xsync::Ins().initialize(xsync_udp_factory);
-  Xsync::Ins().changeXsyncIp(xsyncIp);
-}
+void    XsyncInit(I_XSUDPFactory *xsync_udp_factory) { g_xsync_udp_factory = xsync_udp_factory; }
 IXsync *XsyncIns() { return &Xsync::Ins(); }
 }  // namespace xsync