electrocardiograph_upper/mainwindow.cpp

#include "mainwindow.h"

#include <QDateTime>
#include <QtConcurrent>

#include "./ui_mainwindow.h"

using namespace iflytop;
using namespace xsync;
using namespace std;

static MainWindow *m_mainWindow;
#define TAG "MainWindow"

static const char *fmt(const char *fmt, ...) {
  va_list args;
  va_start(args, fmt);
  static char buf[1024] = {0};
  vsnprintf(buf, sizeof(buf), fmt, args);
  va_end(args);
  return buf;
}

static const uint32_t str2int(QString str) {
  // 如果0x开头，按16进制转换
  // 如果0b开头，按2进制转换
  // 否则按10进制转换

  // 去除掉str中_
  str.remove("_");

  if (str.startsWith("0x")) {
    return str.toUInt(nullptr, 16);
  } else if (str.startsWith("0b")) {
    // remove 0b
    str.remove(0, 2);
    return str.toUInt(nullptr, 2);
  } else {
    return str.toUInt(nullptr, 10);
  }
}

void MainWindow::log_output(QtMsgType type, const QMessageLogContext &context, const QString &msg) {
  QString text;
  text.append(msg);
  m_mainWindow->append_log_signal(text);
}

void MainWindow::append_log_slot(QString text) { ui->logbrowser->append(text); }

void MainWindow::updateUI_timeCodeInfo_slot(QString text) { ui->TimecodeDisplayer->setText(text); }
void MainWindow::updateUI_cameraSyncInfo_slot(QString text) { ui->CameraSyncIndex->setText(text); }
void MainWindow::updateUI_reg_slot(int32_t regadd, uint32_t regval) {
  auto it = m_regdisplayer.find(regadd);
  if (it != m_regdisplayer.end()) {
    ZLOGI(TAG, "updateUI_reg_slot %x %d", regadd, regval);
    it->second->regBrowser->setText(QString::number(regval, 16));
  }
}
void MainWindow::doinui_slot(QFunction func) {
  if (func.get()) func.get()();
}

void MainWindow::push_reg(QWidget *parent, int off, const char *regname, int32_t regadd, int32_t rwflag, reg_val_type_t regvaltype) {
  DispalyRegIterm *regitem = new DispalyRegIterm();
  regitem->regvaltype      = regvaltype;
  {
    auto *label = new QLabel(parent);
    label->setObjectName(QString::fromUtf8("label"));
    label->setText(QString(fmt("%s(0x%04x)", regname, regadd)));
    QSizePolicy sizePolicy1(QSizePolicy::Minimum, QSizePolicy::Expanding);
    sizePolicy1.setHorizontalStretch(0);
    sizePolicy1.setVerticalStretch(0);
    sizePolicy1.setHeightForWidth(label->sizePolicy().hasHeightForWidth());
    label->setSizePolicy(sizePolicy1);
    label->setMinimumSize(QSize(250, 0));
    label->setMaximumSize(QSize(16777215, 16777215));
    ui->reg_table->addWidget(label, off, 0, 1, 1);
    regitem->label = label;
  }
  {
    auto *textbrowser = new QTextBrowser(parent);
    textbrowser->setObjectName(QString::fromUtf8("textbrowser"));
    textbrowser->setEnabled(true);
    textbrowser->setText(QString("unset"));
    QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    sizePolicy.setHorizontalStretch(0);
    sizePolicy.setVerticalStretch(0);
    sizePolicy.setHeightForWidth(textbrowser->sizePolicy().hasHeightForWidth());

    textbrowser->setSizePolicy(sizePolicy);
    textbrowser->setMaximumSize(QSize(16777215, 16777215));

    ui->reg_table->addWidget(textbrowser, off, 1, 1, 1);
    regitem->regBrowser = textbrowser;
  }

  {
    auto *textEdit = new QTextEdit(parent);
    textEdit->setObjectName(QString::fromUtf8("textEdit"));
    textEdit->setEnabled(true);
    QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    sizePolicy.setHorizontalStretch(0);
    sizePolicy.setVerticalStretch(0);
    sizePolicy.setHeightForWidth(textEdit->sizePolicy().hasHeightForWidth());

    textEdit->setSizePolicy(sizePolicy);
    textEdit->setMaximumSize(QSize(16777215, 16777215));

    ui->reg_table->addWidget(textEdit, off, 2, 1, 1);
    regitem->regEditer = textEdit;
  }
  {
    // new button
    auto *button = new QPushButton(parent);
    button->setObjectName(QString::fromUtf8("button"));
    button->setText(QString("Write"));
    QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    sizePolicy.setHorizontalStretch(0);
    sizePolicy.setVerticalStretch(0);
    sizePolicy.setHeightForWidth(button->sizePolicy().hasHeightForWidth());
    button->setSizePolicy(sizePolicy);

    // connect(this,
    connect(button, &QPushButton::clicked, [this, regadd](bool) {  //
      QString  regval_str = m_regdisplayer[regadd]->regEditer->toPlainText();
      uint32_t regval     = str2int(regval_str);
      ZLOGI(TAG, "write reg 0x%04x %d", regadd, regval);

      uint32_t readbackval = 0;
      auto     ecode       = Xsync::Ins().reg_write(regadd, regval, readbackval);
      if (ecode == kxs_ec_success) {
        ZLOGI(TAG, "write reg 0x%04x %d success", regadd, regval);
        m_regdisplayer[regadd]->regvalcache = readbackval;
        updateUI_timeCodeInfo(regadd);
      } else {
        ZLOGE(TAG, "write reg 0x%04x %d fail,ecode:%s", regadd, regval, xs_error_code_2_str(ecode));
      }

    });

    regitem->writerButton = button;
    ui->reg_table->addWidget(button, off, 3, 1, 1);
  }
  m_regdisplayer[regadd] = regitem;
}

void MainWindow::updateUI_timeCodeInfo(uint32_t regoff) {
  // m_regdisplayer[regoff]->regBrowser->setText("0x" + QString::number(regValue, 16));

  uint32_t       regval     = m_regdisplayer[regoff]->regvalcache;
  auto          *regBrowser = m_regdisplayer[regoff]->regBrowser;
  reg_val_type_t regvaltype = m_regdisplayer[regoff]->regvaltype;

  if (regvaltype == kreg_val_type_dotted_hex) {
    regBrowser->setText(QString(fmt("%02x.%02x.%02x.%02x", (regval >> 0) & 0xff, (regval >> 8) & 0xff, (regval >> 16) & 0xff, (regval >> 24) & 0xff)));
  } else if (regvaltype == kreg_val_type_dotted_decimal) {
    regBrowser->setText(QString(fmt("%d.%d.%d.%d", (regval >> 0) & 0xff, (regval >> 8) & 0xff, (regval >> 16) & 0xff, (regval >> 24) & 0xff)));
  } else if (regvaltype == kreg_val_type_str) {
    char text[5] = {0};
    memcpy(text, &regval, 4);
    regBrowser->setText(QString(text));
  } else if (regvaltype == kreg_val_type_hex) {
    regBrowser->setText(QString(fmt("0x%08x", regval)));
  } else if (regvaltype == kreg_val_type_decimal) {
    regBrowser->setText(QString::number(regval, 10));
  } else if (regvaltype == kreg_val_type_binary) {
    regBrowser->setText(QString::number(regval, 2));
  }
}

void MainWindow::construct_reg_table() {  //
  int regoff = 1;

  push_reg(ui->gridLayoutWidget, regoff++, "software_version", reg::ksoftware_version, 0, kreg_val_type_dotted_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "manufacturer0", reg::kmanufacturer0, 0, kreg_val_type_str);
  push_reg(ui->gridLayoutWidget, regoff++, "manufacturer1", reg::kmanufacturer1, 0, kreg_val_type_str);
  push_reg(ui->gridLayoutWidget, regoff++, "product_type_id", reg::kproduct_type_id, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "sn_id0", reg::ksn_id0, 0, kreg_val_type_dotted_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "sn_id1", reg::ksn_id1, 0, kreg_val_type_dotted_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "sn_id2", reg::ksn_id2, 0, kreg_val_type_dotted_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "mac0", reg::kmac0, 0, kreg_val_type_dotted_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "mac1", reg::kmac1, 0, kreg_val_type_dotted_hex);

  // reg::kstm32_ip
  // reg::kstm32_gw
  // reg::kstm32_netmask
  // reg::kstm32_camera_sync_signal_count

  push_reg(ui->gridLayoutWidget, regoff++, "stm32_ip", reg::kstm32_ip, 0, kreg_val_type_dotted_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "stm32_gw", reg::kstm32_gw, 0, kreg_val_type_dotted_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "stm32_netmask", reg::kstm32_netmask, 0, kreg_val_type_dotted_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "stm32_camera_sync_signal_count", reg::kstm32_camera_sync_signal_count, 0, kreg_val_type_decimal);

  push_reg(ui->gridLayoutWidget, regoff++, "fpga_reg_test_reg0", reg::kfpga_test_reg0, 0, kreg_val_type_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "fpga_reg_test_reg1", reg::kfpga_test_reg1, 0, kreg_val_type_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "fpga_reg_test_reg2", reg::kfpga_test_reg2, 0, kreg_val_type_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "fpga_reg_test_reg3", reg::kfpga_test_reg3, 0, kreg_val_type_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "fpga_reg_test_reg4", reg::kfpga_test_reg4, 0, kreg_val_type_hex);

  push_reg(ui->gridLayoutWidget, regoff++, "ttlout1_input_sig_slt", reg::kttlout1_input_sig_slt, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout1_output_sig_slt", reg::kttlout1_output_sig_slt, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout1_config", reg::kttlout1_config, 0, kreg_val_type_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout1_pulse_mode_duration", reg::kttlout1_pulse_mode_duration, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout1_pulse_mode_delay", reg::kttlout1_pulse_mode_delay, 0, kreg_val_type_decimal);

  push_reg(ui->gridLayoutWidget, regoff++, "ttlout2_input_sig_slt", reg::kttlout2_input_sig_slt, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout2_output_sig_slt", reg::kttlout2_output_sig_slt, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout2_config", reg::kttlout2_config, 0, kreg_val_type_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout2_pulse_mode_duration", reg::kttlout2_pulse_mode_duration, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout2_pulse_mode_delay", reg::kttlout2_pulse_mode_delay, 0, kreg_val_type_decimal);

  push_reg(ui->gridLayoutWidget, regoff++, "ttlout3_input_sig_slt", reg::kttlout3_input_sig_slt, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout3_output_sig_slt", reg::kttlout3_output_sig_slt, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout3_config", reg::kttlout3_config, 0, kreg_val_type_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout3_pulse_mode_duration", reg::kttlout3_pulse_mode_duration, 0, kreg_val_type_decimal);

  push_reg(ui->gridLayoutWidget, regoff++, "ttlout3_pulse_mode_delay", reg::kttlout3_pulse_mode_delay, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout4_input_sig_slt", reg::kttlout4_input_sig_slt, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout4_output_sig_slt", reg::kttlout4_output_sig_slt, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout4_config", reg::kttlout4_config, 0, kreg_val_type_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "ttlout4_pulse_mode_duration", reg::kttlout4_pulse_mode_duration, 0, kreg_val_type_decimal);

  push_reg(ui->gridLayoutWidget, regoff++, "SigGenerator_ctl", reg::kSigGenerator_ctl, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "SigGenerator_genlock_format", reg::kSigGenerator_genlock_format, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "SigGenerator_timecode_format", reg::kSigGenerator_timecode_format, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "SigGenerator_control_trigger_reg", reg::kSigGenerator_control_trigger_reg, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "SigGenerator_timecode0", reg::kSigGenerator_timecode0, 0, kreg_val_type_dotted_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "SigGenerator_timecode1", reg::kSigGenerator_timecode1, 0, kreg_val_type_dotted_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "SigGenerator_timecode_start0", reg::kSigGenerator_timecode_start0, 0, kreg_val_type_dotted_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "SigGenerator_timecode_start1", reg::kSigGenerator_timecode_start1, 0, kreg_val_type_dotted_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "SigGenerator_work_state", reg::kSigGenerator_work_state, 0, kreg_val_type_decimal);

  push_reg(ui->gridLayoutWidget, regoff++, "camera_sync_out_camera_sync_select", reg::kcamera_sync_out_camera_sync_select, 0, kreg_val_type_decimal);

  // ktimecode_in_timecode_sig_selt
  // ktimecode_in_timecode_format
  // ktimecode_in_timecode0
  // ktimecode_in_timecode1

  push_reg(ui->gridLayoutWidget, regoff++, "timecode_in_timecode_sig_selt", reg::ktimecode_in_timecode_sig_selt, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "timecode_in_timecode_format", reg::ktimecode_in_timecode_format, 0, kreg_val_type_decimal);
  push_reg(ui->gridLayoutWidget, regoff++, "timecode_in_timecode0", reg::ktimecode_in_timecode0, 0, kreg_val_type_dotted_hex);
  push_reg(ui->gridLayoutWidget, regoff++, "timecode_in_timecode1", reg::ktimecode_in_timecode1, 0, kreg_val_type_dotted_hex);

  // 设置table的高度
  auto qrect = ui->gridLayoutWidget->geometry();
  qrect.setHeight(31 * regoff - 1);
  ui->gridLayoutWidget->setGeometry(qrect);
}
//
void MainWindow::UI_TTLOutputMoudleConstruct() {
  ui->TTLOutputMoudle_ID->clear();
  for (int i = 1; i <= 4; i++) {
    ui->TTLOutputMoudle_ID->addItem(QString::number(i));
  }

  ui->TTLOutputMoudle_InputSigType->clear();
  for (auto &str : ttlout_module::TriggerSigTypeStrSet()) {
    ui->TTLOutputMoudle_InputSigType->addItem(QString::fromStdString(str));
  }

  ui->TTLOutputMoudle_OutputSigType->clear();
  for (auto &str : ttlout_module::OutputSigTypeStrSet()) {
    ui->TTLOutputMoudle_OutputSigType->addItem(QString::fromStdString(str));
  }
}

void MainWindow::UI_SigGeneratorConstruct() {
  ui->SigGenerator_ControlMode->clear();
  for (auto &str : sig_generator_module::ControlModeStrSet()) {
    ui->SigGenerator_ControlMode->addItem(QString::fromStdString(str));
  }

  ui->SigGenerator_GenlockFormat->clear();
  for (auto &str : GenlockFormatStrSet()) {
    ui->SigGenerator_GenlockFormat->addItem(QString::fromStdString(str));
  }

  ui->SigGenerator_TimecodeFormat->clear();
  for (auto &str : TimecodeFormatStrSet()) {
    ui->SigGenerator_TimecodeFormat->addItem(QString::fromStdString(str));
  }
}

void MainWindow::UI_TimecodeOutputModuleConstruct() {
  ui->TimecodeOutputModule_TimecodeSrcSelect->clear();
  for (auto &str : timecode_output_module::TriggerSigTypeStrSet()) {
    ui->TimecodeOutputModule_TimecodeSrcSelect->addItem(QString::fromStdString(str));
  }

  ui->TimecodeOutputModule_BncOutputLevel->clear();
  for (auto &str : timecode_output_module::OutputSigLevelTypeStrSet()) {
    ui->TimecodeOutputModule_BncOutputLevel->addItem(QString::fromStdString(str));
  }

  ui->TimecodeOutputModule_HeadphoneOutputLevel->clear();
  for (auto &str : timecode_output_module::OutputSigLevelTypeStrSet()) {
    ui->TimecodeOutputModule_HeadphoneOutputLevel->addItem(QString::fromStdString(str));
  }

  ui->TimecodeOutputModule_TimecodeFormat->clear();
  for (auto &str : TimecodeFormatStrSet()) {
    ui->TimecodeOutputModule_TimecodeFormat->addItem(QString::fromStdString(str));
  }
}

void MainWindow::UI_CameraSyncPacketGeneratorModuleConstruct() {
  ui->CameraSyncPacketGeneratorModule_TriggerSig->clear();
  for (auto &str : camera_sync_packet_generator_module::TriggerSigTypeStrSet()) {
    ui->CameraSyncPacketGeneratorModule_TriggerSig->addItem(QString::fromStdString(str));
  }
}

void MainWindow::UI_TimecodeInModuleConstruct() {
  ui->TimecodeInputModule_Format->clear();
  for (auto &str : TimecodeFormatStrSet()) {
    ui->TimecodeInputModule_Format->addItem(QString::fromStdString(str));
  }

  ui->TimecodeInputModule_TriggerSigType->clear();
  for (auto &str : timecode_input_module::TriggerSigTypeStrSet()) {
    ui->TimecodeInputModule_TriggerSigType->addItem(QString::fromStdString(str));
  }
}
void MainWindow::UI_TTLInModuleConstruct() {
  ui->TTLInputModule_Index->clear();
  for (int i = 1; i <= 4; i++) {
    ui->TTLInputModule_Index->addItem(QString::number(i));
  }
}

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
  ui->setupUi(this);
  m_mainWindow = this;

  /**
   * @brief 填充部分UI
   */
  construct_reg_table();
  qInstallMessageHandler(log_output);
  UI_TTLOutputMoudleConstruct();
  UI_SigGeneratorConstruct();
  UI_TimecodeOutputModuleConstruct();
  UI_CameraSyncPacketGeneratorModuleConstruct();
  UI_TimecodeInModuleConstruct();
  UI_TTLInModuleConstruct();

  /*******************************************************************************
   *                                连接信号与槽                                 *
   *******************************************************************************/

  qRegisterMetaType<int32_t>("int32_t");
  qRegisterMetaType<uint32_t>("uint32_t");
  qRegisterMetaType<function<void()>>("function<void()>");
  qRegisterMetaType<QFunction>("QFunction");

  XSyncUdpFactoryImpl::Ins()->initialize();
  connect(this, SIGNAL(append_log_signal(QString)), this, SLOT(append_log_slot(QString)));
  connect(this, SIGNAL(updateUI_timeCodeInfo_signal(QString)), this, SLOT(updateUI_timeCodeInfo_slot(QString)));
  connect(this, SIGNAL(updateUI_cameraSyncInfo_signal(QString)), this, SLOT(updateUI_cameraSyncInfo_slot(QString)));
  connect(this, SIGNAL(updateUI_reg_signal(int32_t, uint32_t)), this, SLOT(updateUI_reg_slot(int32_t, uint32_t)));
  connect(this, SIGNAL(doinui_signal(QFunction)), this, SLOT(doinui_slot(QFunction)));
  m_thread.reset(new ZQThread("test", [this]() { mainWindowsRun(); }));
  m_thread->start();

  // m_xsync.reset(new Xsync());

  Xsync::Ins().initialize(XSyncUdpFactoryImpl::Ins());
  Xsync::Ins().Basic_registerOnTimecodeMsgCallback([this](XsyncTimecode_t *timecode_msg) {  //
    XsyncTimecode_t timecode = *timecode_msg;
    QString         text     = QString(fmt("%02d:%02d:%02d:%02d", timecode.hour, timecode.minute, timecode.second, timecode.frame));
    updateUI_timeCodeInfo_signal(text);
  });

  Xsync::Ins().Basic_registerOnCameraSyncMsgCallback([this](xysnc_camera_sync_data_t *camera_sync_msg) {  //
    xysnc_camera_sync_data_t camera_sync_data = *camera_sync_msg;
    updateUI_cameraSyncInfo_signal(QString(fmt("%d", camera_sync_data.frameIndex)));
  });

  Xsync::Ins().Basic_registerOnWorkstateChangeMsgCallback([this](uint32_t workstate) {
    emit doinui_signal(QFunction([this, workstate]() { ui->WorkState->setText(QString::number(workstate)); }));
  });
}

MainWindow::~MainWindow() { delete ui; }

#define XS_ASSERT(exptr)                                 \
  {                                                      \
    auto ecode = exptr;                                  \
    while (!(ecode == kxs_ec_success)) {                 \
      ZLOGE(TAG, "do: %s fail,ecode:%d", #exptr, ecode); \
      ZQThread::sleep(1);                                \
    }                                                    \
  }

void MainWindow::on_RefreshRegsButton_clicked() {  //
  ZLOGI(TAG, "on_refreshRegsButton_clicked");
  // int32_t _t1, uint32_t _t2

  QtConcurrent::run([this]() {
    bool suc = true;
    for (auto &reg : m_regdisplayer) {
      uint32_t regValue = 0;
      auto     ecode    = Xsync::Ins().reg_read(reg.first, regValue);
      int      regoff   = reg.first;

      if (ecode == kxs_ec_success) {
        ZLOGI(TAG, "reg_read %x success", reg.first);
        m_regdisplayer[regoff]->regvalcache = regValue;
        emit doinui_signal(QFunction([this, regoff, regValue]() { updateUI_timeCodeInfo(regoff); }));
      } else {
        emit doinui_signal(QFunction([this, regoff, regValue]() {
          m_regdisplayer[regoff]->regvalcache = 0;
          m_regdisplayer[regoff]->regBrowser->setText("error");
        }));
      }
    }
  });
}
void MainWindow::on_ClearLogButton_clicked() {  //
  ui->logbrowser->clear();
}
void MainWindow::on_Connect2XsyncButton_clicked() {  //
  ZLOGI(TAG, "connect %s", ui->IpInput->text().toStdString().c_str());
  xs_error_code_t ecode = Xsync::Ins().connect(ui->IpInput->text().toStdString());
  ZLOGI(TAG, "connect %s ecode:%s", ui->IpInput->text().toStdString().c_str(), xs_error_code_2_str(ecode));
}
void MainWindow::mainWindowsRun() {  //

  // auto xsudp = XSyncUdpFactoryImpl::Ins()->createXSUDP();
  // XS_ASSERT(xsudp->initialize("0.0.0.0", 9999));
  // xsudp->startReceive([this, xsudp](XsyncNetAdd &from, uint8_t *data, size_t length) {
  //   // ZLOGI(TAG, "receive from <%s:%d> (%d) :%s", from.ip.c_str(), from.port, data, length);
  //   xsudp->sendto(from, "hello\n", 5, NULL);
  // });
}

#define DO_XSYNC_FUNC(exptr)                                                               \
  {                                                                                        \
    auto ecode = exptr;                                                                    \
    if (!(ecode == kxs_ec_success)) {                                                      \
      ZLOGE(TAG, "do: %s fail,ecode:[%d](%s)", #exptr, ecode, xs_error_code_2_str(ecode)); \
      return;                                                                              \
    } else {                                                                               \
      ZLOGI(TAG, "do: %s success", #exptr);                                                \
    }                                                                                      \
  }

void MainWindow::on_GenNewMac_clicked() { DO_XSYNC_FUNC(Xsync::Ins().Basic_generatorNewMac()); }
void MainWindow::on_FactoryReset_clicked() { DO_XSYNC_FUNC(Xsync::Ins().Basic_factoryReset()); }
void MainWindow::on_Reboot_clicked() { DO_XSYNC_FUNC(Xsync::Ins().Basic_reboot()); }
void MainWindow::on_ChangeNetCfg_clicked() {  //
  DO_XSYNC_FUNC(Xsync::Ins().Basic_changeNetworkConfig(ui->ChangeNetCfg_ip->text().toStdString(), ui->ChangeNetCfg_mask->text().toStdString(), ui->ChangeNetCfg_gateway->text().toStdString()));
}

void MainWindow::on_WriteReg_clicked() {
  uint32_t regadd = str2int(ui->RegAdd->text());
  uint32_t regval = str2int(ui->RegVal->text());

  ZLOGI(TAG, "write reg 0x%08x %d", regadd, regval);
  uint32_t readbakval = 0;
  DO_XSYNC_FUNC(Xsync::Ins().reg_write(regadd, regval, readbakval));

  ZLOGI(TAG, "write reg 0x%08x 0x%08x ,readback:0x%08x success", regadd, regval, readbakval);
  ui->RegVal->setText(QString(fmt("0x%08x", readbakval)));
}
void MainWindow::on_ReadReg_clicked() {
  uint32_t regadd = str2int(ui->RegAdd->text());
  uint32_t regval = 0;
  DO_XSYNC_FUNC(Xsync::Ins().reg_read(regadd, regval));
  ZLOGI(TAG, "read reg 0x%08x 0x%08x success", regadd, regval);
  ui->RegVal->setText(QString(fmt("0x%08x", regval)));
}

void MainWindow::on_TTLOutputMoudle_Update_clicked() {
  int32_t ID =  //
      ui->TTLOutputMoudle_ID->currentText().toInt();
  auto InputSigType =  //
      ttlout_module::Str2TriggerSigType(ui->TTLOutputMoudle_InputSigType->currentText().toStdString());
  auto OutputSigType =  //
      ttlout_module::Str2OutputSigType(ui->TTLOutputMoudle_OutputSigType->currentText().toStdString());
  uint32_t TriggerModePulseWidth =  //
      ui->TTLOutputMoudle_TriggerModePulseWidth->text().toUInt();
  uint32_t TriggerModePulseDelay =  //
      ui->TTLOutputMoudle_TriggerModePulseDelay->text().toUInt();

  ZLOGI(TAG, "on_TTLOutputMoudle_Update_clicked ID:%d InputSigType:%d OutputSigType:%d TriggerModePulseWidth:%d TriggerModePulseDelay:%d",  //
        ID, InputSigType, OutputSigType, TriggerModePulseWidth, TriggerModePulseDelay);

  DO_XSYNC_FUNC(Xsync::Ins().TTLOutputModule_setInputSigType(ID, InputSigType));
  DO_XSYNC_FUNC(Xsync::Ins().TTLOutputModule_setOutputSigType(ID, OutputSigType));
  DO_XSYNC_FUNC(Xsync::Ins().TTLOutputModule_setTriggerModePulseWidth(ID, TriggerModePulseWidth));
  DO_XSYNC_FUNC(Xsync::Ins().TTLOutputModule_setTriggerModePulseDelay(ID, TriggerModePulseDelay));
}

void MainWindow::on_TTLOutputMoudle_Read_clicked() {
  ttlout_module::TriggerSigType_t InputSigType;
  ttlout_module::OutputSigType_t  OutputSigType;
  uint32_t                        TriggerModePulseWidth;
  uint32_t                        TriggerModePulseDelay;

  int32_t ID =  //
      ui->TTLOutputMoudle_ID->currentText().toInt();

  DO_XSYNC_FUNC(Xsync::Ins().TTLOutputModule_getInputSigType(ID, InputSigType));
  DO_XSYNC_FUNC(Xsync::Ins().TTLOutputModule_getOutputSigType(ID, OutputSigType));
  DO_XSYNC_FUNC(Xsync::Ins().TTLOutputModule_getTriggerModePulseWidth(ID, TriggerModePulseWidth));
  DO_XSYNC_FUNC(Xsync::Ins().TTLOutputModule_getTriggerModePulseDelay(ID, TriggerModePulseDelay));

  ui->TTLOutputMoudle_InputSigType->setCurrentText(QString::fromStdString(ttlout_module::TriggerSigType2Str(InputSigType)));
  ui->TTLOutputMoudle_OutputSigType->setCurrentText(QString::fromStdString(ttlout_module::OutputSigType2Str(OutputSigType)));
  ui->TTLOutputMoudle_TriggerModePulseWidth->setText(QString::number(TriggerModePulseWidth));
  ui->TTLOutputMoudle_TriggerModePulseDelay->setText(QString::number(TriggerModePulseDelay));
}

void MainWindow::on_SigGenerator_Read_clicked() {
  sig_generator_module::ControlMode_t ControlMode;
  GenlockFormat_t                     GenlockFormat;
  TimecodeFormat_t                    TimecodeFormat;
  XsyncTimecode_t                     Timecode;
  XsyncTimecode_t                     AutoStartTimecode;
  uint32_t                            WorkState;

  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_getControlMode(ControlMode));
  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_getGenlockFormat(GenlockFormat));
  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_getTimecodeFormat(TimecodeFormat));
  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_getTimecode(Timecode));
  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_getAutoStartTimecode(AutoStartTimecode));
  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_getWorkState(WorkState));

  ui->SigGenerator_ControlMode->setCurrentText(QString::fromStdString(sig_generator_module::ControlMode2Str(ControlMode)));
  ui->SigGenerator_GenlockFormat->setCurrentText(QString::fromStdString(GenlockFormatToStr(GenlockFormat)));
  ui->SigGenerator_TimecodeFormat->setCurrentText(QString::fromStdString(TimecodeFormatToStr(TimecodeFormat)));
  ui->SigGenerator_Timecode->setText(QString(XsyncTimecodeToStr(Timecode).c_str()));
  ui->SigGenerator_AutoStartTimecode->setText(QString(XsyncTimecodeToStr(AutoStartTimecode).c_str()));
  ui->SigGenerator_WorkState->setText(QString::number(WorkState));
}
void MainWindow::on_SigGenerator_Update_clicked() {
  auto            ControlMode       = sig_generator_module::Str2ControlMode(ui->SigGenerator_ControlMode->currentText().toStdString());
  auto            GenlockFormat     = Str2GenlockFormat(ui->SigGenerator_GenlockFormat->currentText().toStdString());
  auto            TimecodeFormat    = Str2TimecodeFormat(ui->SigGenerator_TimecodeFormat->currentText().toStdString());
  XsyncTimecode_t timecode          = Str2XsyncTimecode(ui->SigGenerator_Timecode->text().toStdString());
  XsyncTimecode_t autoStartTimecode = Str2XsyncTimecode(ui->SigGenerator_AutoStartTimecode->text().toStdString());

  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_setControlMode(ControlMode));
  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_setGenlockFormat(GenlockFormat));
  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_setTimecodeFormat(TimecodeFormat));
  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_setTimecode(timecode));
  DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_setAutoStartTimecode(autoStartTimecode));
}
void MainWindow::on_SigGenerator_Start_clicked() { DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_manualStart()); }
void MainWindow::on_SigGenerator_Stop_clicked() { DO_XSYNC_FUNC(Xsync::Ins().SigGenerator_manualStop()); }

void MainWindow::on_TimecodeOutputModule_Read_clicked() {
  // TimecodeOutputModule_TimecodeSrcSelect
  // TimecodeOutputModule_BncOutputLevel
  // TimecodeOutputModule_HeadphoneOutputLevel
  // TimecodeOutputModule_TimecodeFormat
  // TimecodeOutputModule_TimecodeNow

  timecode_output_module::TriggerSigType_t     TimecodeSrcSelect;
  timecode_output_module::OutputSigLevelType_t BncOutputLevel;
  timecode_output_module::OutputSigLevelType_t HeadphoneOutputLevel;
  TimecodeFormat_t                             TimecodeFormat;
  XsyncTimecode_t                              TimecodeNow;

  DO_XSYNC_FUNC(Xsync::Ins().TimecodeOutputModule_getTimecodeSrcSelect(TimecodeSrcSelect));
  DO_XSYNC_FUNC(Xsync::Ins().TimecodeOutputModule_getBncOutputLevel(BncOutputLevel));
  DO_XSYNC_FUNC(Xsync::Ins().TimecodeOutputModule_getHeadphoneOutputLevel(HeadphoneOutputLevel));
  DO_XSYNC_FUNC(Xsync::Ins().TimecodeOutputModule_getTimecodeFormat(TimecodeFormat));
  DO_XSYNC_FUNC(Xsync::Ins().TimecodeOutputModule_getTimecodeNow(TimecodeNow));

  ui->TimecodeOutputModule_TimecodeSrcSelect->setCurrentText(QString::fromStdString(timecode_output_module::TriggerSigType2Str(TimecodeSrcSelect)));
  ui->TimecodeOutputModule_BncOutputLevel->setCurrentText(QString::fromStdString(timecode_output_module::OutputSigLevelType2Str(BncOutputLevel)));
  ui->TimecodeOutputModule_HeadphoneOutputLevel->setCurrentText(QString::fromStdString(timecode_output_module::OutputSigLevelType2Str(HeadphoneOutputLevel)));
  ui->TimecodeOutputModule_TimecodeFormat->setCurrentText(QString::fromStdString(TimecodeFormatToStr(TimecodeFormat)));
  ui->TimecodeOutputModule_TimecodeNow->setText(QString(XsyncTimecodeToStr(TimecodeNow).c_str()));
}
void MainWindow::on_TimecodeOutputModule_Update_clicked() {
  auto TimecodeSrcSelect    = timecode_output_module::Str2TriggerSigType(ui->TimecodeOutputModule_TimecodeSrcSelect->currentText().toStdString());
  auto BncOutputLevel       = timecode_output_module::Str2OutputSigLevelType(ui->TimecodeOutputModule_BncOutputLevel->currentText().toStdString());
  auto HeadphoneOutputLevel = timecode_output_module::Str2OutputSigLevelType(ui->TimecodeOutputModule_HeadphoneOutputLevel->currentText().toStdString());

  DO_XSYNC_FUNC(Xsync::Ins().TimecodeOutputModule_setTimecodeSrcSelect(TimecodeSrcSelect));
  DO_XSYNC_FUNC(Xsync::Ins().TimecodeOutputModule_setBncOutputLevel(BncOutputLevel));
  DO_XSYNC_FUNC(Xsync::Ins().TimecodeOutputModule_setHeadphoneOutputLevel(HeadphoneOutputLevel));
}

void MainWindow::on_CameraSyncPacketGeneratorModule_Update_clicked() {
  auto TriggerSig   = camera_sync_packet_generator_module::Str2TriggerSigType(ui->CameraSyncPacketGeneratorModule_TriggerSig->currentText().toStdString());
  auto ReportPeriod = ui->CameraSyncPacketGeneratorModule_ReportPeriod->text().toUInt();

  DO_XSYNC_FUNC(Xsync::Ins().CameraSyncPacketGeneratorModule_setTriggerSig(TriggerSig));
  DO_XSYNC_FUNC(Xsync::Ins().CameraSyncPacketGeneratorModule_setReportPeriod(ReportPeriod));
}
void MainWindow::on_CameraSyncPacketGeneratorModule_Read_clicked() {
  camera_sync_packet_generator_module::TriggerSigType_t TriggerSig;

  uint32_t ReportPeriod;
  uint32_t PacketIndex;

  DO_XSYNC_FUNC(Xsync::Ins().CameraSyncPacketGeneratorModule_getTriggerSig(TriggerSig));
  DO_XSYNC_FUNC(Xsync::Ins().CameraSyncPacketGeneratorModule_getReportPeriod(ReportPeriod));
  DO_XSYNC_FUNC(Xsync::Ins().CameraSyncPacketGeneratorModule_getPacketIndex(PacketIndex));

  ui->CameraSyncPacketGeneratorModule_TriggerSig->setCurrentText(QString::fromStdString(camera_sync_packet_generator_module::TriggerSigType2Str(TriggerSig)));
  ui->CameraSyncPacketGeneratorModule_ReportPeriod->setText(QString::number(ReportPeriod));
  ui->CameraSyncPacketGeneratorModule_PacketIndex->setText(QString::number(PacketIndex));
}
void MainWindow::on_CameraSyncPacketGeneratorModule_ClearPacketIndex_clicked() {
  DO_XSYNC_FUNC(Xsync::Ins().CameraSyncPacketGeneratorModule_clearPacketIndex());
  on_CameraSyncPacketGeneratorModule_Read_clicked();
}

void MainWindow::on_TTLInputModule_Read_clicked() {
  int32_t  Index = ui->TTLInputModule_Index->currentText().toInt();
  uint32_t DivideFactor;
  uint32_t FilterFactor;
  bool     En;

  DO_XSYNC_FUNC(Xsync::Ins().TTLInputModule_getDivideFactor(Index, DivideFactor));
  DO_XSYNC_FUNC(Xsync::Ins().TTLInputModule_getFilterFactor(Index, FilterFactor));
  DO_XSYNC_FUNC(Xsync::Ins().TTLInputModule_getEn(Index, En));

  ui->TTLInputModule_DivideFactor->setText(QString::number(DivideFactor));
  ui->TTLInputModule_FilterFactor->setText(QString::number(FilterFactor));
  ui->TTLInputModule_En->setText(QString::number(En));
}
void MainWindow::on_TTLInputModule_Update_clicked() {
  int32_t  Index = ui->TTLInputModule_Index->currentText().toInt();
  uint32_t DivideFactor;
  uint32_t FilterFactor;
  bool     En;

  DivideFactor = ui->TTLInputModule_DivideFactor->text().toUInt();
  FilterFactor = ui->TTLInputModule_FilterFactor->text().toUInt();
  En           = ui->TTLInputModule_En->text().toUInt();

  DO_XSYNC_FUNC(Xsync::Ins().TTLInputModule_setDivideFactor(Index, DivideFactor));
  DO_XSYNC_FUNC(Xsync::Ins().TTLInputModule_setFilterFactor(Index, FilterFactor));
  DO_XSYNC_FUNC(Xsync::Ins().TTLInputModule_setEn(Index, En));
}

void MainWindow::on_TimecodeInputModule_Read_clicked() {
  TimecodeFormat_t                        Format;
  timecode_input_module::TriggerSigType_t TriggerSig;
  XsyncTimecode_t                         Timecode;

  DO_XSYNC_FUNC(Xsync::Ins().TimecodeInputModule_getSrcSelect(TriggerSig));
  DO_XSYNC_FUNC(Xsync::Ins().TimecodeInputModule_getTimecodeFormat(Format));
  DO_XSYNC_FUNC(Xsync::Ins().TimecodeInputModule_getTimecode(Timecode));

  // ZLOGI(TAG, "on_TimecodeInputModule_Read_clicked TriggerSig:%d Format:%d Timecode:%d %d %d %d", TriggerSig, Format, Timecode.hour, Timecode.minute, Timecode.second, Timecode.frame);

  ui->TimecodeInputModule_TriggerSigType->setCurrentText(QString::fromStdString(timecode_input_module::TriggerSigType2Str(TriggerSig)));
  ui->TimecodeInputModule_Format->setCurrentText(QString::fromStdString(TimecodeFormatToStr(Format)));
  ui->TimecodeInputModule_Timecode->setText(QString(XsyncTimecodeToStr(Timecode).c_str()));
}
void MainWindow::on_TimecodeInputModule_Update_clicked() {
  auto             TriggerSig = timecode_input_module::Str2TriggerSigType(ui->TimecodeInputModule_TriggerSigType->currentText().toStdString());
  TimecodeFormat_t Format     = Str2TimecodeFormat(ui->TimecodeInputModule_Format->currentText().toStdString());

  DO_XSYNC_FUNC(Xsync::Ins().TimecodeInputModule_setSrcSelect(TriggerSig));
  DO_XSYNC_FUNC(Xsync::Ins().TimecodeInputModule_setTimecodeFormat(Format));
}

void MainWindow::on_tabWidget_currentChanged(int index) {
  index = index + 1;
  if (index == 0) {
  } else if (index == 1) {
    on_RefreshRegsButton_clicked();
  } else if (index == 2) {
  } else if (index == 3) {
    on_TTLOutputMoudle_Read_clicked();
  } else if (index == 4) {
    on_SigGenerator_Read_clicked();
  } else if (index == 5) {
    on_TimecodeOutputModule_Read_clicked();
  } else if (index == 6) {
    on_CameraSyncPacketGeneratorModule_Read_clicked();
  } else if (index == 7) {
    on_TimecodeInputModule_Read_clicked();
  } else if (index == 8) {
    on_TTLInputModule_Read_clicked();
  }
}

void MainWindow::on_TTLInputModule_Index_currentIndexChanged(int index) { on_TTLInputModule_Read_clicked(); }
void MainWindow::on_TTLOutputMoudle_ID_currentIndexChanged(int index) { on_TTLOutputMoudle_Read_clicked(); }