libxsync/xsync.cpp

#include "xsync.hpp"
#define ENABLE_LOG
#ifdef ENABLE_LOG
#include "../src/logger.hpp"
#endif

#define TAG "XSYNC"

using namespace iflytop;

static uint32_t ipToUint32(const std::string &ipAddress, bool &suc) {
  uint32_t           result = 0;
  std::istringstream iss(ipAddress);
  std::string        segment;
  int                i = 0;

  while (std::getline(iss, segment, '.')) {
    uint32_t octet = std::stoi(segment);
    if (octet > 255) {
      suc = false;
      return 0;
    }
    result |= (octet << ((3 - i) * 8));
    i++;
  }
  if (i != 4) {
    suc = false;
    return 0;
  }
  suc = true;

  uint32_t result_n = 0;
  result_n |= ((result & 0xff000000) >> 24);
  result_n |= ((result & 0x00ff0000) >> 8);
  result_n |= ((result & 0x0000ff00) << 8);
  result_n |= ((result & 0x000000ff) << 24);

  return result_n;
}
namespace iflytop {
namespace xsync_internal_signal {

// level0 = 0,  // 0
// level1 = 1,  // 1

// ttlin1_module_raw_sig    = 2,  // ttl1输入模块原始信号
// ttlin1_module_sig_divide = 3,  // ttl1输入模块分频信号
// ttlin2_module_raw_sig    = 4,  // ttl2输入模块原始信号
// ttlin2_module_sig_divide = 5,  // ttl2输入模块分频信号
// ttlin3_module_raw_sig    = 6,  // ttl3输入模块原始信号
// ttlin3_module_sig_divide = 7,  // ttl3输入模块分频信号
// ttlin4_module_raw_sig    = 8,  // ttl4输入模块原始信号
// ttlin4_module_sig_divide = 9,  // ttl4输入模块分频信号

// genlockin_module_freq_sig     = 10,  // genlock输入模块频率信号
// timecodein_module_trigger_sig = 11,  // timecode输入模块触发信号

// internal_camera_sync_sig      = 12,  // 内部相机同步信号
// internal_timecode_trigger_sig = 13,  // 内部timecode触发信号
// internal_genlock_freq_sig     = 14,  // 内部genlock频率信号
// internal_work_state_sig       = 15   // 内部工作状态信号

std::string signal_type_to_str(signal_type_t type) {
  switch (type) {
    case level0:
      return "level0";
    case level1:
      return "level1";
    case ttlin1_module_raw_sig:
      return "ttlin1_module_raw_sig";
    case ttlin1_module_sig_divide:
      return "ttlin1_module_sig_divide";
    case ttlin2_module_raw_sig:
      return "ttlin2_module_raw_sig";
    case ttlin2_module_sig_divide:
      return "ttlin2_module_sig_divide";
    case ttlin3_module_raw_sig:
      return "ttlin3_module_raw_sig";
    case ttlin3_module_sig_divide:
      return "ttlin3_module_sig_divide";
    case ttlin4_module_raw_sig:
      return "ttlin4_module_raw_sig";
    case ttlin4_module_sig_divide:
      return "ttlin4_module_sig_divide";
    case genlockin_module_freq_sig:
      return "genlockin_module_freq_sig";
    case timecodein_module_trigger_sig:
      return "timecodein_module_trigger_sig";
    case internal_camera_sync_sig:
      return "internal_camera_sync_sig";
    case internal_timecode_trigger_sig:
      return "internal_timecode_trigger_sig";
    case internal_genlock_freq_sig:
      return "internal_genlock_freq_sig";
    case internal_work_state_sig:
      return "internal_work_state_sig";
    default:
      return "unknow";
  }
  return "unknow";
}
signal_type_t str_to_signal_type(std::string type) {
  if (type == "level0") return level0;
  if (type == "level1") return level1;
  if (type == "ttlin1_module_raw_sig") return ttlin1_module_raw_sig;
  if (type == "ttlin1_module_sig_divide") return ttlin1_module_sig_divide;
  if (type == "ttlin2_module_raw_sig") return ttlin2_module_raw_sig;
  if (type == "ttlin2_module_sig_divide") return ttlin2_module_sig_divide;
  if (type == "ttlin3_module_raw_sig") return ttlin3_module_raw_sig;
  if (type == "ttlin3_module_sig_divide") return ttlin3_module_sig_divide;
  if (type == "ttlin4_module_raw_sig") return ttlin4_module_raw_sig;
  if (type == "ttlin4_module_sig_divide") return ttlin4_module_sig_divide;
  if (type == "genlockin_module_freq_sig") return genlockin_module_freq_sig;
  if (type == "timecodein_module_trigger_sig") return timecodein_module_trigger_sig;
  if (type == "internal_camera_sync_sig") return internal_camera_sync_sig;
  if (type == "internal_timecode_trigger_sig") return internal_timecode_trigger_sig;
  if (type == "internal_genlock_freq_sig") return internal_genlock_freq_sig;
  if (type == "internal_work_state_sig") return internal_work_state_sig;
  return level0;
}
}  // namespace xsync_internal_signal
}  // namespace iflytop

namespace iflytop {
namespace xsync_ttlout_module {

string output_signal_type_to_str(output_signal_type_t type) {
  switch (type) {
    case level0:
      return "level0";
    case level1:
      return "level1";
    case test_signal:
      return "test_signal";
    case input_signal:
      return "input_signal";
    case input_signal_mirror:
      return "input_signal_mirror";
    case trigger_mode_signal:
      return "trigger_mode_signal";
    case trigger_mode_signal_mirror:
      return "trigger_mode_signal_mirror";
    default:
      return "unknow";
  }
  return "unknow";
}
output_signal_type_t str_to_output_signal_type(string type) {
  if (type == "level0") return level0;
  if (type == "level1") return level1;
  if (type == "test_signal") return test_signal;
  if (type == "input_signal") return input_signal;
  if (type == "input_signal_mirror") return input_signal_mirror;
  if (type == "trigger_mode_signal") return trigger_mode_signal;
  if (type == "trigger_mode_signal_mirror") return trigger_mode_signal_mirror;
  return level0;
}
}  // namespace xsync_ttlout_module
}  // namespace iflytop

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

  m_net_state = kxsync_net_state_connected;
  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;
  }

  m_net_state = kxsync_net_state_disconnect;
  return kxs_ec_success;
}
xsync_net_state_t Xsync::getNetState() { return m_net_state; }

void Xsync::Basic_registerOnTimecodeMsgCallback(xsync_on_timecode_msg_t on_timecode_msg_cb) { m_on_timecode_msg_cb = on_timecode_msg_cb; }
void Xsync::Basic_registerOnCameraSyncMsgCallback(xsync_on_camera_sync_msg_t on_camera_sync_msg_cb) { m_on_camera_sync_msg_cb = on_camera_sync_msg_cb; }

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;
  m_xsync_reg_udp->clearRxBuffer();

  cmd->index = txpacket_index++;

  XsyncNetAdd     toadd = {m_xsync_ip, 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) {
    return ecode;
  }

  XsyncNetAdd fromadd;
  while (true) {
    // ZLOGI(TAG, "start rx wait for rxdata");
    ecode = m_xsync_reg_udp->receive((char *)rx_data, buffersize, fromadd, overtime_ms);
    // ZLOGI(TAG, "end rx wait for rxdata");
    if (ecode != kxs_ec_success) {
      return ecode;
    }
    if (rx_data->index != cmd->index) {
      // ZLOGI(TAG, "packet index error %d %d", cmd->index, rx_data->index);
      continue;
    }
    break;
  }

  return (xs_error_code_t)rx_data->data[0];
}

xs_error_code_t Xsync::reg_write(uint32_t regadd, uint32_t regvalue, uint32_t &regbackvalue, int32_t overtime_ms) {
  /**
   * @brief
   *      协议说明
   *
   * kxsync_packet_type_reg_write
   *  tx: regadd,regdata
   *  rx: ecode,regdata
   */

  uint8_t txdata[128] = {0};
  uint8_t rxdata[128] = {0};

  iflytop_xsync_packet_header_t *txpacket = (iflytop_xsync_packet_header_t *)txdata;
  iflytop_xsync_packet_header_t *rxpacket = (iflytop_xsync_packet_header_t *)rxdata;

  txpacket->type    = kxsync_packet_type_cmd;
  txpacket->index   = txpacket_index++;
  txpacket->cmd     = kxsync_packet_type_reg_write;
  txpacket->ndata   = 2;
  txpacket->data[0] = regadd;
  txpacket->data[1] = regvalue;

  auto ecode = xsync_send_cmd_block(txpacket, rxpacket, sizeof(rxdata), overtime_ms);
  if (ecode != kxs_ec_success) {
    return ecode;
  }

  regbackvalue = rxpacket->data[1];
  return ecode;
}

xs_error_code_t Xsync::reg_read(uint32_t regadd, uint32_t &regvalue, int32_t overtime_ms) {
  /**
   * @brief
   *      协议说明
   *
   * kxsync_packet_type_reg_write
   *  tx: regadd,regdata
   *  rx: ecode,regdata
   */

  uint8_t txdata[128] = {0};
  uint8_t rxdata[128] = {0};

  iflytop_xsync_packet_header_t *txpacket = (iflytop_xsync_packet_header_t *)txdata;
  iflytop_xsync_packet_header_t *rxpacket = (iflytop_xsync_packet_header_t *)rxdata;

  txpacket->type    = kxsync_packet_type_cmd;
  txpacket->index   = txpacket_index++;
  txpacket->cmd     = kxsync_packet_type_reg_read;
  txpacket->ndata   = 2;
  txpacket->data[0] = regadd;
  txpacket->data[1] = regvalue;

  auto ecode = xsync_send_cmd_block(txpacket, rxpacket, sizeof(rxdata), overtime_ms);
  if (ecode != kxs_ec_success) {
    return ecode;
  }
  regvalue = rxpacket->data[1];
  return ecode;
}
xs_error_code_t Xsync::reg_read_muti(uint32_t regadd, uint32_t nreg, vector<uint32_t> &regvalues, int32_t overtime_ms) {
  /**
   * @brief
   *      协议说明
   *
   * kxsync_packet_type_reg_read_regs
   *  tx: regstartadd,nreg
   *  rx: ecode,regdatas
   */

  uint8_t txdata[128]  = {0};
  uint8_t rxdata[1280] = {0};

  iflytop_xsync_packet_header_t *txpacket = (iflytop_xsync_packet_header_t *)txdata;
  iflytop_xsync_packet_header_t *rxpacket = (iflytop_xsync_packet_header_t *)rxdata;

  txpacket->type    = kxsync_packet_type_cmd;
  txpacket->index   = txpacket_index++;
  txpacket->cmd     = kxsync_packet_type_reg_read_regs;
  txpacket->ndata   = 2;
  txpacket->data[0] = regadd;
  txpacket->data[1] = nreg;

  auto ecode = xsync_send_cmd_block(txpacket, rxpacket, sizeof(rxdata), overtime_ms);
  if (ecode != kxs_ec_success) {
    return ecode;
  }

  if (rxpacket->ndata > 0) {
    for (int i = 0; i < rxpacket->ndata - 1; i++) {
      regvalues.push_back(rxpacket->data[i + 1]);
    }
  }
  return ecode;
}

void Xsync::parseTimecodeMsgAndReport(XsyncNetAdd &from, uint8_t *data, size_t length) {
  //
  iflytop_timecode_report_packet_t *packet = (iflytop_timecode_report_packet_t *)data;
  xysnc_timecode_t                  timecode;
  /**
   * @brief
   *
   * 01 02 03 04 01 02 03 04
   *
   */

  uint8_t frameuints  = packet->timecode0 & 0x0f;
  uint8_t frame10s    = (packet->timecode0 >> 8) & 0x3;
  uint8_t seconduints = (packet->timecode0 >> 16) & 0x0f;
  uint8_t second10s   = (packet->timecode0 >> 24) & 0x03;

  uint8_t minuteuints = packet->timecode1 & 0x0f;
  uint8_t minute10s   = (packet->timecode1 >> 8) & 0x03;
  uint8_t houruints   = (packet->timecode1 >> 16) & 0x0f;
  uint8_t hour10s     = (packet->timecode1 >> 24) & 0x03;

  timecode.hour   = hour10s * 10 + houruints;
  timecode.minute = minute10s * 10 + minuteuints;
  timecode.second = second10s * 10 + seconduints;
  timecode.frame  = frame10s * 10 + frameuints;

  if (m_on_timecode_msg_cb) m_on_timecode_msg_cb(&timecode);
}
void Xsync::parseCameraSyncMsgAndReport(XsyncNetAdd &from, uint8_t *data, size_t length) {
  uint32_t count = 0;

  uint32_t data0 = data[7];
  uint32_t data1 = data[6];
  uint32_t data2 = data[5];
  uint32_t data3 = data[4];

  count = data0 + (data1 << 8) + (data2 << 16) + (data3 << 24);

  xysnc_camera_sync_data_t camera_sync_data;
  camera_sync_data.frameIndex = count;

  if (m_on_camera_sync_msg_cb) m_on_camera_sync_msg_cb(&camera_sync_data);
}

// xsync_stm32_action_generator_new_mac,  //
// xsync_stm32_action_factory_reset,      //
// xsync_stm32_action_Basic_reboot,             //
// xsync_stm32_action_storage_cfg,
xs_error_code_t Xsync::Basic_generatorNewMac() { return doaction(xsync_stm32_action_generator_new_mac, 0, nullptr, 2000); }
xs_error_code_t Xsync::Basic_factoryReset() { return doaction(xsync_stm32_action_factory_reset, 0, nullptr, 1000); }
xs_error_code_t Xsync::Basic_reboot() { return doaction(xsync_stm32_action_Basic_reboot, 0, nullptr); }
xs_error_code_t Xsync::storageConfig() { return doaction(xsync_stm32_action_storage_cfg, 0, nullptr, 1000); }
xs_error_code_t Xsync::Basic_changeNetworkConfig(string ip, string mask, string gateway) {
  uint32_t        ip32      = 0;
  uint32_t        mask32    = 0;
  uint32_t        gateway32 = 0;
  xs_error_code_t ecode;
  bool            suc = false;

  ip32 = (uint32_t)ipToUint32(ip.c_str(), suc);
  if (!suc) return kxs_ec_param_error;
  mask32 = (uint32_t)ipToUint32(mask.c_str(), suc);
  if (!suc) return kxs_ec_param_error;
  gateway32 = (uint32_t)ipToUint32(gateway.c_str(), suc);
  if (!suc) return kxs_ec_param_error;

  uint32_t readbak = 0;

  ecode = reg_write(kxsync_reg_stm32_ip, ip32, readbak);
  if (ecode != kxs_ec_success) return ecode;
  ecode = reg_write(kxsync_reg_stm32_netmask, mask32, readbak);
  if (ecode != kxs_ec_success) return ecode;
  ecode = reg_write(kxsync_reg_stm32_gw, gateway32, readbak);
  if (ecode != kxs_ec_success) return ecode;

  ecode = storageConfig();
  if (ecode != kxs_ec_success) return ecode;

  return kxs_ec_success;
}

xs_error_code_t Xsync::Basic_clearXsyncCameraSyncIndexCount() {
  uint32_t readbak = 0;
  return reg_write(kxsync_reg_stm32_camera_sync_signal_count, 0, readbak);
}

xs_error_code_t Xsync::doaction(uint32_t action, uint32_t actionval, uint32_t *ackreturn, int32_t overtime_ms) {
  //
  uint32_t        readbak = 0;
  xs_error_code_t ecode;
  ecode = reg_write(kxsync_reg_stm32_action_val0, actionval, readbak);
  if (ecode != kxs_ec_success) return ecode;

  ecode = reg_write(kxsync_reg_stm32_action0, action, readbak, overtime_ms);
  if (ecode != kxs_ec_success) return ecode;
  if (ackreturn) *ackreturn = readbak;
  return ecode;
}

/*******************************************************************************
 *                               TTLOutputModule                               *
 *******************************************************************************/
// .reg0(reg_input_signal_select),
// .reg1(reg_output_signal_select),
// .reg2(reg_config),
// .reg3(reg_pulse_mode_valid_len),
// .reg4(reg_pulse_mode_trigger_delay)

xs_error_code_t Xsync::TTLOutputModule_getRegOff(int32_t index, uint32_t &regadd) {
  switch (index) {
    case 1:
      regadd = REG_ADD_OFF_TTLOUT1;
      break;
    case 2:
      regadd = REG_ADD_OFF_TTLOUT2;
      break;
    case 3:
      regadd = REG_ADD_OFF_TTLOUT3;
      break;
    case 4:
      regadd = REG_ADD_OFF_TTLOUT4;
      break;
    default:
      return kxs_ec_param_error;
  }
  return kxs_ec_success;
}

xs_error_code_t Xsync::TTLOutputModule_setInputSigType(int32_t index, xsync_internal_signal::signal_type_t source) {
  uint32_t        regadd  = REG_ADD_OFF_TTLOUT1;
  xs_error_code_t ecode   = kxs_ec_success;
  uint32_t        readbak = 0;

  ecode = TTLOutputModule_getRegOff(index, regadd);
  if (ecode != kxs_ec_success) return ecode;

  return reg_write(regadd + 0, source, readbak, 10);
}

xs_error_code_t Xsync::TTLOutputModule_getInputSigType(int32_t index, xsync_internal_signal::signal_type_t &source) {
  uint32_t        regadd  = REG_ADD_OFF_TTLOUT1;
  xs_error_code_t ecode   = kxs_ec_success;
  uint32_t        readbak = 0;

  ecode = TTLOutputModule_getRegOff(index, regadd);
  if (ecode != kxs_ec_success) return ecode;

  ecode = reg_read(regadd + 0, readbak, 10);
  if (ecode != kxs_ec_success) return ecode;

  source = (xsync_internal_signal::signal_type_t)readbak;
  return ecode;
}

xs_error_code_t Xsync::TTLOutputModule_setOutputSigType(int32_t index, xsync_ttlout_module::output_signal_type_t output_type) {
  uint32_t        regadd  = REG_ADD_OFF_TTLOUT1;
  xs_error_code_t ecode   = kxs_ec_success;
  uint32_t        readbak = 0;

  ecode = TTLOutputModule_getRegOff(index, regadd);
  if (ecode != kxs_ec_success) return ecode;

  return reg_write(regadd + 1, output_type, readbak, 10);
}
xs_error_code_t Xsync::TTLOutputModule_getOutputSigType(int32_t index, xsync_ttlout_module::output_signal_type_t &output_type) {
  uint32_t        regadd  = REG_ADD_OFF_TTLOUT1;
  xs_error_code_t ecode   = kxs_ec_success;
  uint32_t        readbak = 0;

  ecode = TTLOutputModule_getRegOff(index, regadd);
  if (ecode != kxs_ec_success) return ecode;

  ecode = reg_read(regadd + 1, readbak, 10);
  if (ecode != kxs_ec_success) return ecode;

  output_type = (xsync_ttlout_module::output_signal_type_t)readbak;
  return ecode;
}

xs_error_code_t Xsync::TTLOutputModule_setTriggerModePulseWidth(int32_t index, uint32_t pulse_width_ms) {
  uint32_t        regadd  = REG_ADD_OFF_TTLOUT1;
  xs_error_code_t ecode   = kxs_ec_success;
  uint32_t        readbak = 0;

  ecode = TTLOutputModule_getRegOff(index, regadd);
  if (ecode != kxs_ec_success) return ecode;

  uint32_t pluse_width = pulse_width_ms * 1000;  // 1MHZ计数

  return reg_write(regadd + 3, pluse_width, readbak, 10);
}
xs_error_code_t Xsync::TTLOutputModule_getTriggerModePulseWidth(int32_t index, uint32_t &pulse_width_ms) {
  uint32_t        regadd  = REG_ADD_OFF_TTLOUT1;
  xs_error_code_t ecode   = kxs_ec_success;
  uint32_t        readbak = 0;

  ecode = TTLOutputModule_getRegOff(index, regadd);
  if (ecode != kxs_ec_success) return ecode;

  ecode = reg_read(regadd + 3, readbak, 10);
  if (ecode != kxs_ec_success) return ecode;

  pulse_width_ms = readbak / 1000;
  return ecode;
}

xs_error_code_t Xsync::TTLOutputModule_setTriggerModePulseDelay(int32_t index, uint32_t pulse_delay_ms) {
  uint32_t        regadd  = REG_ADD_OFF_TTLOUT1;
  xs_error_code_t ecode   = kxs_ec_success;
  uint32_t        readbak = 0;

  ecode = TTLOutputModule_getRegOff(index, regadd);
  if (ecode != kxs_ec_success) return ecode;

  uint32_t pulse_delay = pulse_delay_ms * 1000;  // 1MHZ计数

  return reg_write(regadd + 4, pulse_delay, readbak, 10);
}
xs_error_code_t Xsync::TTLOutputModule_getTriggerModePulseDelay(int32_t index, uint32_t &pulse_delay_ms) {
  uint32_t        regadd  = REG_ADD_OFF_TTLOUT1;
  xs_error_code_t ecode   = kxs_ec_success;
  uint32_t        readbak = 0;

  ecode = TTLOutputModule_getRegOff(index, regadd);
  if (ecode != kxs_ec_success) return ecode;

  ecode = reg_read(regadd + 4, readbak, 10);
  if (ecode != kxs_ec_success) return ecode;

  pulse_delay_ms = readbak / 1000;
  return ecode;
}