You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1057 lines
44 KiB
1057 lines
44 KiB
#include "xsync_v2.hpp"
|
|
|
|
#include <string.h>
|
|
|
|
#include <map>
|
|
|
|
#include "../src/logger.hpp"
|
|
#include "xsync_errcode.hpp"
|
|
#include "xsync_regs.hpp"
|
|
#include "xsync_utils.hpp"
|
|
#include "xsync_v2_sig_type.hpp"
|
|
|
|
#define TAG "XSYNC"
|
|
|
|
using namespace xsync;
|
|
using namespace std;
|
|
|
|
/**
|
|
* @brief XSYNC协议端口
|
|
*/
|
|
#define IFLYTOP_XSYNC_SERVICE_XSYNC_PORT 19900 // xsync端端口
|
|
#define IFLYTOP_XSYNC_SERVICE_PC_PORT 19901 // pc 端端口
|
|
|
|
#define IFLYTOP_XSYNC_TIMECODE_REPORT_XSYNC_PORT 19902 // xsync端端口
|
|
#define IFLYTOP_XSYNC_TIMECODE_REPORT_PC_PORT 19903 // pc端端口
|
|
|
|
#define IFLYTOP_XSYNC_CAMERA_SYNC_PACKET_XSYNC_PORT 13013 // xsync端端口
|
|
#define IFLYTOP_XSYNC_CAMERA_SYNC_PACKET_PC_PORT 13014 // pc端端口
|
|
|
|
#define DO_XSYNC(exptr) \
|
|
{ \
|
|
xs_error_code_t ecode = exptr; \
|
|
if (ecode != kxs_ec_success) return ecode; \
|
|
}
|
|
|
|
#define REG_WRITE(reg, value) \
|
|
{ \
|
|
DO_XSYNC(reg_write(reg, value, 10)); \
|
|
return kxs_ec_success; \
|
|
}
|
|
|
|
#define REG_READ(reg, value) \
|
|
{ \
|
|
uint32_t readbak = 0; \
|
|
DO_XSYNC(reg_read(reg, readbak, 10)); \
|
|
value = (decltype(value))readbak; \
|
|
return kxs_ec_success; \
|
|
}
|
|
|
|
I_XSUDPFactory *g_xsync_udp_factory = nullptr;
|
|
|
|
class RxContext {
|
|
public:
|
|
std::recursive_mutex lock_;
|
|
|
|
uint8_t rxpacket[1024] = {0};
|
|
int32_t rxpacket_length = 0;
|
|
bool m_isready = false;
|
|
bool m_isWait = false;
|
|
|
|
int32_t m_expectIndex = 0;
|
|
|
|
void setRxPacket(uint8_t *data, int32_t length) {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
memcpy(rxpacket, data, length);
|
|
rxpacket_length = length;
|
|
m_isready = true;
|
|
}
|
|
|
|
void clear() {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
memset(rxpacket, 0, sizeof(rxpacket));
|
|
rxpacket_length = 0;
|
|
m_isready = false;
|
|
m_isWait = false;
|
|
m_expectIndex = 0;
|
|
}
|
|
|
|
void setWait(bool wait, int32_t waitIndex) {
|
|
lock_guard<recursive_mutex> lock(lock_);
|
|
m_isWait = wait;
|
|
m_expectIndex = waitIndex;
|
|
}
|
|
|
|
bool isReady() { return m_isready; }
|
|
bool isWait() { return m_isWait; }
|
|
|
|
int32_t getExpectIndex() { return m_expectIndex; }
|
|
|
|
uint8_t *data() { return rxpacket; }
|
|
size_t size() { return rxpacket_length; }
|
|
};
|
|
|
|
class Xsync : public IXsync {
|
|
private:
|
|
/* data */
|
|
|
|
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;
|
|
|
|
string m_xsync_ip;
|
|
bool m_is_connected = false;
|
|
|
|
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;
|
|
|
|
RxContext rxContext;
|
|
|
|
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_is_connected, m_xsync_ip);
|
|
}
|
|
|
|
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() {
|
|
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);
|
|
xsync_reg_udp->startReceive([this](XsyncNetAdd &from, uint8_t *data, size_t length) {
|
|
iflytop_xsync_packet_header_t *rx_data = (iflytop_xsync_packet_header_t *)data;
|
|
if (!rxContext.isWait()) {
|
|
return;
|
|
}
|
|
|
|
if (rx_data->index != rxContext.getExpectIndex()) {
|
|
return;
|
|
}
|
|
|
|
rxContext.setRxPacket(data, length);
|
|
});
|
|
|
|
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];
|
|
tc64.subframe = packet->data[2];
|
|
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 = {0};
|
|
tc64.tc0 = packet->data[1];
|
|
tc64.tc1 = packet->data[2]; // TODO:需要锁存时码的子帧
|
|
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
|
|
// 相机同步包
|
|
if (config->listenCameraSyncPacket) {
|
|
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;
|
|
// ZLOGI(TAG, "%lld ", has_not_receive_packet_time_s);
|
|
if (m_is_connected && (has_not_receive_packet_time_s) > 500) {
|
|
_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;
|
|
}
|
|
|
|
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 bool getConnectState() override { return _getConnectState(); }
|
|
virtual string getDeviceIp() override { return _getXsyncIp(); }
|
|
|
|
virtual xs_error_code_t NetworkConfig_setMode(NetworkMode_t mode) override { REG_WRITE(reg::kstm32_obtaining_ip_mode, mode); }
|
|
virtual xs_error_code_t NetworkConfig_getMode(NetworkMode_t &mode) override {
|
|
uint32_t mode_u32;
|
|
DO_XSYNC(reg_read(reg::kstm32_obtaining_ip_mode, mode_u32, 10));
|
|
mode = (NetworkMode_t)mode_u32;
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
virtual xs_error_code_t NetworkConfigStaticIpMode_setIp(string ip) override {
|
|
xs_error_code_t ecode;
|
|
bool suc = false;
|
|
uint32_t ip32 = (uint32_t)ipToUint32(ip.c_str(), suc);
|
|
if (!suc) return kxs_ec_param_error;
|
|
|
|
uint32_t readbak = 0;
|
|
|
|
ecode = reg_write(reg::kstm32_ip, ip32, readbak);
|
|
if (ecode != kxs_ec_success) return ecode;
|
|
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t NetworkConfigStaticIpMode_setMask(string mask) override {
|
|
xs_error_code_t ecode;
|
|
bool suc = false;
|
|
uint32_t mask32 = (uint32_t)ipToUint32(mask.c_str(), suc);
|
|
if (!suc) return kxs_ec_param_error;
|
|
|
|
uint32_t readbak = 0;
|
|
|
|
ecode = reg_write(reg::kstm32_netmask, mask32, readbak);
|
|
if (ecode != kxs_ec_success) return ecode;
|
|
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t NetworkConfigStaticIpMode_setGateway(string gateway) override {
|
|
xs_error_code_t ecode;
|
|
bool suc = false;
|
|
uint32_t gateway32 = (uint32_t)ipToUint32(gateway.c_str(), suc);
|
|
if (!suc) return kxs_ec_param_error;
|
|
|
|
uint32_t readbak = 0;
|
|
|
|
ecode = reg_write(reg::kstm32_gw, gateway32, readbak);
|
|
if (ecode != kxs_ec_success) return ecode;
|
|
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
virtual xs_error_code_t NetworkConfigStaticIpMode_getIp(string &ip) override {
|
|
uint32_t ip32;
|
|
DO_XSYNC(reg_read(reg::kstm32_ip, ip32, 10));
|
|
ip = uint32ToIp(ip32);
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t NetworkConfigStaticIpMode_getMask(string &mask) override {
|
|
uint32_t mask32;
|
|
DO_XSYNC(reg_read(reg::kstm32_netmask, mask32, 10));
|
|
|
|
mask = uint32ToIp(mask32);
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t NetworkConfigStaticIpMode_getGateway(string &gateway) override {
|
|
uint32_t gateway32;
|
|
DO_XSYNC(reg_read(reg::kstm32_gw, gateway32, 10));
|
|
|
|
gateway = uint32ToIp(gateway32);
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
virtual xs_error_code_t readSDKVersion(version_t &version) override {
|
|
version.main = PC_VERSION >> 16;
|
|
version.sub = (PC_VERSION >> 8) & 0xff;
|
|
version.fix = PC_VERSION & 0xff;
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t readARMSoftwareVersion(version_t &version) override {
|
|
uint32_t version_u32;
|
|
DO_XSYNC(reg_read(reg::ksoftware_version, version_u32, 10));
|
|
version.main = version_u32 >> 16;
|
|
version.sub = (version_u32 >> 8) & 0xff;
|
|
version.fix = version_u32 & 0xff;
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t readFPGASoftwareVersion(version_t &version) override {
|
|
uint32_t version_u32;
|
|
DO_XSYNC(reg_read(reg::kfpga_info_reg0, version_u32, 10));
|
|
version.main = version_u32 >> 16;
|
|
version.sub = (version_u32 >> 8) & 0xff;
|
|
version.fix = version_u32 & 0xff;
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
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 readSn(string &sn) override;
|
|
virtual xs_error_code_t readMac(string &mac) override;
|
|
|
|
public:
|
|
virtual xs_error_code_t reg_write(uint32_t regadd, uint32_t regvalue, uint32_t ®backvalue, int32_t overtime_ms = 100) override;
|
|
virtual xs_error_code_t reg_read(uint32_t regadd, uint32_t ®value, int32_t overtime_ms = 100) override;
|
|
|
|
public:
|
|
/*******************************************************************************
|
|
* TIMECODE *
|
|
*******************************************************************************/
|
|
virtual xs_error_code_t ExternalTimecode_readCode(XsyncTimecode_t &timecode) override { //
|
|
return readtimecode(reg::external_timecode_timecode0, reg::external_timecode_timecode1, timecode);
|
|
}
|
|
virtual xs_error_code_t ExternalTimecode_readSrc(InputInterface_t &timecode_select) override {
|
|
uint32_t readbak = 0;
|
|
DO_XSYNC(reg_read(reg::external_timecode_timecode_sig_selt, readbak, 10));
|
|
if (readbak == 1) {
|
|
timecode_select = INPUT_IF_TIMECODE_BNC;
|
|
} else if (readbak == 2) {
|
|
timecode_select = INPUT_IF_TIMECODE_HEADPHONE;
|
|
} else if (readbak == 0) {
|
|
timecode_select = INPUT_IF_OFF;
|
|
} else {
|
|
timecode_select = INPUT_IF_OFF;
|
|
}
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t ExternalTimecode_readFreq(float &freq) override { //
|
|
return readfreq(reg::external_timecode_freq, freq);
|
|
}
|
|
virtual xs_error_code_t ExternalTimecode_readFormat(TimecodeFormat_t &format) override { //
|
|
return readTimecodeFormat(reg::external_timecode_freq, reg::external_timecode_timecode0, reg::external_timecode_timecode1, format);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* INTERNAL *
|
|
*******************************************************************************/
|
|
virtual xs_error_code_t InternalSigSrouce_start() override { //
|
|
DO_XSYNC(reg_write(reg::internal_sig_en_contrler_en, 0x7, 10));
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t InternalSigSrouce_stop() override { //
|
|
DO_XSYNC(reg_write(reg::internal_sig_en_contrler_en, 0x0, 10));
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t InternalSigSrouce_readState(bool &en) override {
|
|
uint32_t en_u32;
|
|
DO_XSYNC(reg_read(reg::internal_sig_en_contrler_en, en_u32, 10));
|
|
en = en_u32;
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
virtual xs_error_code_t InternalTimecode_setFormat(TimecodeFormat_t format) override { REG_WRITE(reg::internal_timecode_format, format); }
|
|
virtual xs_error_code_t InternalTimecode_getFormat(TimecodeFormat_t &format) override { REG_READ(reg::internal_timecode_format, format); }
|
|
virtual xs_error_code_t InternalTimecode_setCode(XsyncTimecode_t timecode) override {
|
|
DO_XSYNC(reg_write(reg::internal_timecode_en, 0));
|
|
DO_XSYNC(writetimecode(reg::internal_timecode_data0, reg::internal_timecode_data1, timecode));
|
|
DO_XSYNC(reg_write(reg::internal_timecode_en, 1));
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t InternalTimecode_getCode(XsyncTimecode_t &timecode) override { return readtimecode(reg::internal_timecode_data0, reg::internal_timecode_data1, timecode); }
|
|
virtual xs_error_code_t InternalTimecode_readFreq(float &freq) override { return readfreq(reg::internal_timecode_detect_freq, freq); };
|
|
|
|
virtual xs_error_code_t InternalGenlock_setFormat(GenlockFormat_t format) override { return reg_write(reg::internal_genlock_format, format); }
|
|
virtual xs_error_code_t InternalGenlock_getFormat(GenlockFormat_t &format) override { REG_READ(reg::internal_genlock_format, format); }
|
|
virtual xs_error_code_t InternalGenlock_readFreq(float &freq) override { return readfreq(reg::internal_genlock_freq, freq); }
|
|
|
|
virtual xs_error_code_t InternalClock_setFreq(float freq) override {
|
|
double T = 1.0 / freq;
|
|
double T_ns = T * 1000 * 1000 * 1000;
|
|
double cnt = T_ns / 100 + 0.5; // 10MHZ <=> 100ns
|
|
|
|
uint32_t cnt_u32 = uint32_t(cnt);
|
|
return reg_write(reg::internal_clock_freq, cnt_u32);
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t InternalClock_getFreq(float &freq) override { return readfreq(reg::internal_clock_freq, freq); }
|
|
virtual xs_error_code_t InternalClock_readOutFreq(float &freq) override { return readfreq(reg::internal_clock_freq_detect, freq); }
|
|
|
|
virtual xs_error_code_t SysTimecode_setSource(uint32_t sig) override { REG_WRITE(reg::sys_timecode_select, sig); }
|
|
virtual xs_error_code_t SysTimecode_getSource(uint32_t &sig) override { REG_READ(reg::sys_timecode_select, sig); }
|
|
virtual xs_error_code_t SysTimecode_readFormat(TimecodeFormat_t &format) override { return readTimecodeFormat(reg::sys_timecode_freq_detect, reg::sys_timecode_data0, reg::sys_timecode_data1, format); }
|
|
virtual xs_error_code_t SysTimecode_readFreq(float &freq) override { return readfreq(reg::sys_timecode_freq_detect, freq); }
|
|
virtual xs_error_code_t SysTimecode_readCode(XsyncTimecode_t &timecode) override { return readtimecode(reg::sys_timecode_data0, reg::sys_timecode_data1, timecode); }
|
|
|
|
virtual xs_error_code_t RecordSigGenerator_setContrlMode(ControlMode_t mode) override {
|
|
if (mode != CONTROLMODE_MANUAL_TRIGGER && mode != CONTROLMODE_TIMECODE_TRIGGER && mode != CONTROLMODE_EXTERNALTTL_TRIGGER && mode != CONTROLMODE_EXTERNALTTL_EDGE_TRIGGER) {
|
|
return kxs_ec_param_error;
|
|
}
|
|
return reg_write(reg::record_sig_gen_ctrl_control_mode, mode);
|
|
}
|
|
virtual xs_error_code_t RecordSigGenerator_getContrlMode(ControlMode_t &mode) override { return _reg_read(reg::record_sig_gen_ctrl_control_mode, mode); }
|
|
virtual xs_error_code_t RecordSigGenerator_manualStart() override { return reg_write(reg::record_sig_gen_manual_ctrl, 1, 10); }
|
|
virtual xs_error_code_t RecordSigGenerator_manualStop() override { return reg_write(reg::record_sig_gen_manual_ctrl, 0, 10); }
|
|
virtual xs_error_code_t RecordSigGenerator_setAutoStartTimecode(XsyncTimecode_t timecode) override { return writetimecode(reg::record_sig_gen_timecode_start0, reg::record_sig_gen_timecode_start1, timecode); }
|
|
virtual xs_error_code_t RecordSigGenerator_setAutoStopTimecode(XsyncTimecode_t timecode) override { return writetimecode(reg::record_sig_gen_timecode_stop0, reg::record_sig_gen_timecode_stop1, timecode); }
|
|
virtual xs_error_code_t RecordSigGenerator_getAutoStartTimecode(XsyncTimecode_t &timecode) override { return readtimecode(reg::record_sig_gen_timecode_start0, reg::record_sig_gen_timecode_start1, timecode); }
|
|
virtual xs_error_code_t RecordSigGenerator_getAutoStopTimecode(XsyncTimecode_t &timecode) override { return readtimecode(reg::record_sig_gen_timecode_stop0, reg::record_sig_gen_timecode_stop1, timecode); }
|
|
|
|
virtual xs_error_code_t RecordSigGenerator_setExternalTTLTriggerSrc(InputInterface_t ttlPortNum) override {
|
|
if (ttlPortNum != INPUT_IF_TTL1 && ttlPortNum != INPUT_IF_TTL2 && ttlPortNum != INPUT_IF_TTL3 && ttlPortNum != INPUT_IF_TTL4) {
|
|
return kxs_ec_param_error;
|
|
}
|
|
return reg_write(reg::record_sig_gen_ttlin_trigger_sig_source, ttlPortNum);
|
|
}
|
|
virtual xs_error_code_t RecordSigGenerator_getExternalTTLTriggerSrc(InputInterface_t &ttlPortNum) override { return _reg_read(reg::record_sig_gen_ttlin_trigger_sig_source, ttlPortNum); }
|
|
virtual xs_error_code_t RecordSigGenerator_setExternalTTLTriggerPolarity(uint32_t polarity) override { return reg_write(reg::record_sig_gen_ttlin_trigger_level, polarity); }
|
|
virtual xs_error_code_t RecordSigGenerator_getExternalTTLTriggerPolarity(uint32_t &polarity) override { return _reg_read(reg::record_sig_gen_ttlin_trigger_level, polarity); }
|
|
virtual xs_error_code_t RecordSigGenerator_setTimecodeCtrlFlag(uint32_t autoStart, uint32_t autoStop) override {
|
|
uint32_t flag = (autoStart & 0x01) | ((autoStop & 0x01) << 1);
|
|
return reg_write(reg::record_sig_gen_timecode_control_flag, flag);
|
|
}
|
|
virtual xs_error_code_t RecordSigGenerator_getTimecodeCtrlFlag(uint32_t &autoStart, uint32_t &autoStop) override {
|
|
uint32_t flag = 0;
|
|
auto ret = reg_read(reg::record_sig_gen_timecode_control_flag, flag);
|
|
autoStart = flag & 0x01;
|
|
autoStop = (flag >> 1) & 0x01;
|
|
return ret;
|
|
}
|
|
|
|
virtual xs_error_code_t RecordSigGenerator_getRecordState(uint32_t &state) override { return _reg_read(reg::record_sig_gen_record_state, state); }
|
|
virtual xs_error_code_t RecordSigGenerator_readTimecodeSnapshot(XsyncTimecode_t &timecode) override { return readtimecode(reg::record_sig_gen_timecode_snapshot0, reg::record_sig_gen_timecode_snapshot1, timecode); }
|
|
virtual xs_error_code_t RecordSigGenerator_setTriggerEdge(TriggerEdge_t edge) override { return reg_write(reg::record_sig_gen_trigger_edge_select, edge); }
|
|
virtual xs_error_code_t RecordSigGenerator_getTriggerEdge(TriggerEdge_t &edge) override { return _reg_read(reg::record_sig_gen_trigger_edge_select, edge); }
|
|
|
|
virtual xs_error_code_t TTLOutputModule_setSrcSigType(int index, SignalType_t source) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
|
|
if (source == SIGNAL_LOGIC0 || //
|
|
source == SIGNAL_LOGIC1 || //
|
|
source == SIGNAL_BUSINESS_RECORD_SIG) {
|
|
DO_XSYNC(reg_write(reg::kreg_ttlout1_signal_process_mode + (index - 1) * 16, 3, 10)); // 转发模式
|
|
} else {
|
|
ZLOGI(TAG, "TTLOutputModule_setSrcSigType %d %d", index, source);
|
|
DO_XSYNC(reg_write(reg::kreg_ttlout1_signal_process_mode + (index - 1) * 16, 2, 10)); // 分频倍频模式
|
|
}
|
|
REG_WRITE(reg::kreg_ttlout1_input_signal_select + (index - 1) * 16, source);
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_getSrcSigType(int index, SignalType_t &source) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
uint32_t source_u32;
|
|
DO_XSYNC(reg_read(reg::kreg_ttlout1_input_signal_select + (index - 1) * 16, source_u32, 10));
|
|
source = (SignalType_t)source_u32;
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_setFreqDivision(int index, uint32_t div) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_WRITE(reg::kreg_ttlout1_pllout_freq_division_ctrl + (index - 1) * 16, div);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_getFreqDivision(int index, uint32_t &div) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_READ(reg::kreg_ttlout1_pllout_freq_division_ctrl + (index - 1) * 16, div);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_setFreqMultiplication(int index, uint32_t multi) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_WRITE(reg::kreg_ttlout1_pllout_freq_multiplication_ctrl + (index - 1) * 16, multi);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_getFreqMultiplication(int index, uint32_t &multi) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_READ(reg::kreg_ttlout1_pllout_freq_multiplication_ctrl + (index - 1) * 16, multi);
|
|
}
|
|
|
|
virtual xs_error_code_t TTLOutputModule_readInFreq(int index, float &freq) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
return readfreq(reg::kreg_ttlout1_sig_in_freq_detect + (index - 1) * 16, freq);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_readOutFreq(int index, float &freq) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
return readfreq(reg::kreg_ttlout1_sig_out_freq_detect + (index - 1) * 16, freq);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_setPolarity(int index, uint32_t polarity) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
DO_XSYNC(reg_write(reg::kreg_ttlout1_pllout_polarity_ctrl + (index - 1) * 16, polarity, 10));
|
|
DO_XSYNC(reg_write(reg::kreg_ttlout1_forward_mode_polarity_ctrl + (index - 1) * 16, polarity, 10));
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_getPolarity(int index, uint32_t &polarity) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_READ(reg::kreg_ttlout1_pllout_polarity_ctrl + (index - 1) * 16, polarity);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_setTriggerEdge(int index, TriggerEdge_t edge) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_WRITE(reg::kreg_ttlout1_pllout_trigger_edge_select + (index - 1) * 16, edge);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_getTriggerEdge(int index, TriggerEdge_t &edge) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_READ(reg::kreg_ttlout1_pllout_trigger_edge_select + (index - 1) * 16, edge);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_setPluseWidth(int index, uint32_t us) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_WRITE(reg::kreg_ttlout1_pluse_width_ctrl + (index - 1) * 16, us);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_getPluseWidth(int index, uint32_t &us) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_READ(reg::kreg_ttlout1_pluse_width_ctrl + (index - 1) * 16, us);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_setOffsetTime(int index, uint32_t us) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_WRITE(reg::kreg_ttlout1_pluse_offset_ctrl + (index - 1) * 16, us);
|
|
}
|
|
virtual xs_error_code_t TTLOutputModule_getOffsetTime(int index, uint32_t &us) override {
|
|
if (index < 1 || index > 4) return kxs_ec_param_error;
|
|
REG_READ(reg::kreg_ttlout1_pluse_offset_ctrl + (index - 1) * 16, us);
|
|
}
|
|
|
|
virtual xs_error_code_t Utils_readSigFreq(SignalType_t sig, float &freq) override {
|
|
if (sig == SIGNAL_LOGIC0) {
|
|
freq = 0;
|
|
} else if (sig == SIGNAL_LOGIC1) {
|
|
freq = 0;
|
|
} else if (sig == SIGNAL_TTLIN1) {
|
|
return TTLInputModule1_detectFreq(freq);
|
|
} else if (sig == SIGNAL_TTLIN2) {
|
|
return TTLInputModule2_detectFreq(freq);
|
|
} else if (sig == SIGNAL_TTLIN3) {
|
|
return TTLInputModule3_detectFreq(freq);
|
|
} else if (sig == SIGNAL_TTLIN4) {
|
|
return TTLInputModule4_detectFreq(freq);
|
|
} else if (sig == SIGNAL_EXT_GENLOCK_FREQ) {
|
|
return ExternalGenlock_detectFreq(freq);
|
|
} else if (sig == SIGNAL_EXT_TIMECODE_FREQ) {
|
|
return ExternalTimecode_readFreq(freq);
|
|
} else if (sig == SIGNAL_INTERNAL_TIMECODE_FREQ) {
|
|
return InternalTimecode_readFreq(freq);
|
|
} else if (sig == SIGNAL_INTERNAL_GENLOCK_FREQ) {
|
|
return InternalGenlock_readFreq(freq);
|
|
} else if (sig == SIGNAL_INTERNAL_CLOCK_SIG) {
|
|
return InternalClock_readOutFreq(freq);
|
|
} else if (sig == SIGNAL_SYS_CLK_OUTPUT) {
|
|
return SysClock_readOutSigFreq(freq);
|
|
} else if (sig == SIGNAL_SYS_GENLOCK_OUTPUT) {
|
|
return SysGenlock_readFreq(freq);
|
|
} else if (sig == SIGNAL_SYS_TIMECODE_FREQ_OUTPUT) {
|
|
return SysTimecode_readFreq(freq);
|
|
} else if (sig == SIGNAL_BUSINESS_RECORD_SIG) {
|
|
return kxs_ec_param_error;
|
|
} else if (sig == SIGNAL_BUSINESS_RECORD_EXPOSURE_SIG) {
|
|
return kxs_ec_param_error;
|
|
}
|
|
return kxs_ec_param_error;
|
|
}
|
|
virtual xs_error_code_t TTLInputModule1_detectFreq(float &freq) override { return readfreq(reg::k_ttlin1_freq_detector_reg, freq); }
|
|
virtual xs_error_code_t TTLInputModule2_detectFreq(float &freq) override { return readfreq(reg::k_ttlin2_freq_detector_reg, freq); }
|
|
virtual xs_error_code_t TTLInputModule3_detectFreq(float &freq) override { return readfreq(reg::k_ttlin3_freq_detector_reg, freq); }
|
|
virtual xs_error_code_t TTLInputModule4_detectFreq(float &freq) override { return readfreq(reg::k_ttlin4_freq_detector_reg, freq); }
|
|
virtual xs_error_code_t TimecodeOutputModule_setBncOutputLevel(int level) { REG_WRITE(reg::timecode_output_bnc_outut_level_select, level); }
|
|
virtual xs_error_code_t TimecodeOutputModule_getBncOutputLevel(int &level) { REG_READ(reg::timecode_output_bnc_outut_level_select, level); }
|
|
virtual xs_error_code_t TimecodeOutputModule_setHeadphoneOutputLevel(int level) { REG_WRITE(reg::timecode_output_headphone_outut_level_select, level); }
|
|
virtual xs_error_code_t TimecodeOutputModule_getHeadphoneOutputLevel(int &level) { REG_READ(reg::timecode_output_headphone_outut_level_select, level); }
|
|
virtual xs_error_code_t ExternalGenlock_detectFreq(float &freq) override { return readfreq(reg::external_genlock_freq, freq); }
|
|
virtual xs_error_code_t SysGenlock_setSrc(uint32_t source) override { return reg_write(reg::sys_genlock_source, source); }
|
|
virtual xs_error_code_t SysGenlock_getSrc(uint32_t &extern_or_internal) override {
|
|
REG_READ(reg::sys_genlock_source, extern_or_internal);
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t SysGenlock_readFreq(float &freq) override { return readfreq(reg::sys_genlock_freq, freq); }
|
|
virtual xs_error_code_t SysClock_setSrc(SignalType_t sig) override {
|
|
if (sig != SIGNAL_TTLIN1 && //
|
|
sig != SIGNAL_TTLIN2 && //
|
|
sig != SIGNAL_TTLIN3 && //
|
|
sig != SIGNAL_TTLIN4 && //
|
|
sig != SIGNAL_INTERNAL_CLOCK_SIG && //
|
|
sig != SIGNAL_SYS_GENLOCK_OUTPUT && //
|
|
sig != SIGNAL_SYS_TIMECODE_FREQ_OUTPUT) {
|
|
return kxs_ec_param_error;
|
|
}
|
|
return reg_write(reg::sys_clock_source, sig);
|
|
}
|
|
virtual xs_error_code_t SysClock_getSrc(SignalType_t &sig) override { REG_READ(reg::sys_clock_source, sig); }
|
|
virtual xs_error_code_t SysClock_setTriggerEdge(TriggerEdge_t edge) override { return reg_write(reg::sys_clock_trigger_edge_select, edge); }
|
|
virtual xs_error_code_t SysClock_getTriggerEdge(TriggerEdge_t &edge) override { return _reg_read(reg::sys_clock_trigger_edge_select, edge); }
|
|
virtual xs_error_code_t SysClock_setFreqDivision(uint32_t div) override { return reg_write(reg::sys_clock_freq_division_ctrl, div); }
|
|
virtual xs_error_code_t SysClock_geFreqtDivision(uint32_t &div) override { return _reg_read(reg::sys_clock_freq_division_ctrl, div); }
|
|
virtual xs_error_code_t SysClock_setFreqMultiplication(uint32_t muti) override { return reg_write(reg::sys_clock_freq_multiplication_ctrl, muti); }
|
|
virtual xs_error_code_t SysClock_getFreqMultiplication(uint32_t &muti) override { return _reg_read(reg::sys_clock_freq_multiplication_ctrl, muti); }
|
|
virtual xs_error_code_t SysClock_readOutSigFreq(float &freq) override { return readfreq(reg::sys_clock_outfreq_detect, freq); }
|
|
virtual xs_error_code_t SysClock_readInSigFreq(float &freq) override { return readfreq(reg::sys_clock_infreq_detect, freq); }
|
|
virtual xs_error_code_t storageConfig() override;
|
|
|
|
xs_error_code_t DelayContrl_setDelay(int index, uint32_t delay_us) { //
|
|
DO_XSYNC(reg_write(reg::delayer_delay_sig_index, index, 10));
|
|
DO_XSYNC(reg_write(reg::delayer_delay_us, delay_us, 10));
|
|
return kxs_ec_success;
|
|
}
|
|
xs_error_code_t DelayContrl_getDelay(int index, uint32_t &delay_us) {
|
|
DO_XSYNC(reg_write(reg::delayer_delay_sig_index, index, 10));
|
|
DO_XSYNC(reg_read(reg::delayer_delay_us, delay_us, 10));
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
// assign sys_sig_delay_in[0] = sync_ttl_in1; //
|
|
// assign sys_sig_delay_in[1] = sync_ttl_in2; //
|
|
// assign sys_sig_delay_in[2] = sync_ttl_in3; //
|
|
// assign sys_sig_delay_in[3] = sync_ttl_in4; //
|
|
// assign sys_sig_delay_in[4] = timecode_headphone_in; //
|
|
// assign sys_sig_delay_in[5] = timecode_bnc_in; //
|
|
// assign sys_sig_delay_in[6] = genlock_in_hsync; //
|
|
// assign sys_sig_delay_in[7] = genlock_in_vsync; //
|
|
// assign sys_sig_delay_in[8] = genlock_in_fsync; //
|
|
// assign sys_sig_delay_in[9] = before_delay__sync_ttl_out1; //
|
|
// assign sys_sig_delay_in[10] = before_delay__sync_ttl_out2; //
|
|
// assign sys_sig_delay_in[11] = before_delay__sync_ttl_out3; //
|
|
// assign sys_sig_delay_in[12] = before_delay__sync_ttl_out4; //
|
|
// assign sys_sig_delay_in[13] = before_delay__stm32if_start_signal_out; //
|
|
// assign sys_sig_delay_in[14] = before_delay__stm32if_camera_sync_out; //
|
|
// assign sys_sig_delay_in[15] = before_delay__stm32if_timecode_sync_out; //
|
|
|
|
virtual xs_error_code_t DelayContrl_setInputDelay(uint32_t delay_us) override {
|
|
DO_XSYNC(DelayContrl_setDelay(0, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(1, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(2, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(3, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(4, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(5, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(6, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(7, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(8, delay_us * 10));
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t DelayContrl_getInputDelay(uint32_t &delay_us) override {
|
|
uint32_t delay_cnt;
|
|
DO_XSYNC(DelayContrl_getDelay(8, delay_cnt));
|
|
delay_us = delay_cnt / 10;
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
virtual xs_error_code_t DelayContrl_setOutputDelay(uint32_t delay_us) override {
|
|
DO_XSYNC(DelayContrl_setDelay(9, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(10, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(11, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(12, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(13, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(14, delay_us * 10));
|
|
DO_XSYNC(DelayContrl_setDelay(15, delay_us * 10));
|
|
return kxs_ec_success;
|
|
}
|
|
virtual xs_error_code_t DelayContrl_getOutputDelay(uint32_t &delay_us) override {
|
|
uint32_t delay_cnt;
|
|
DO_XSYNC(DelayContrl_getDelay(15, delay_cnt));
|
|
delay_us = delay_cnt / 10;
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
private:
|
|
xs_error_code_t doaction(uint32_t action, uint32_t actionval, uint32_t *ackreturn, int32_t overtime_ms = 100);
|
|
|
|
xs_error_code_t xsync_send_cmd_block(iflytop_xsync_packet_header_t *cmd, iflytop_xsync_packet_header_t *rx_data, int32_t buffersize, int32_t overtime_ms);
|
|
|
|
xs_error_code_t readtimecode(uint32_t reg0, uint32_t reg1, XsyncTimecode_t &timecode);
|
|
xs_error_code_t writetimecode(uint32_t reg0, uint32_t reg1, XsyncTimecode_t timecode);
|
|
xs_error_code_t readfreq(uint32_t reg, float &freq);
|
|
|
|
xs_error_code_t reg_write(uint32_t regadd, uint32_t regvalue, int32_t overtime_ms = 100);
|
|
xs_error_code_t reg_read_muti(uint32_t regadd, uint32_t nreg, vector<uint32_t> ®values, int32_t overtime_ms = 100);
|
|
|
|
xs_error_code_t readTimecodeFormat(uint32_t freqreg, uint32_t timecode_reg0, uint32_t timecode_reg1, TimecodeFormat_t &format) {
|
|
float freq;
|
|
uint32_t timecode_regval;
|
|
DO_XSYNC(readfreq(freqreg, freq));
|
|
DO_XSYNC(reg_read(timecode_reg0, timecode_regval, 10));
|
|
|
|
uint32_t bit10 = (timecode_regval >> 10) & 0x1;
|
|
|
|
if (Xsync_feq(freq, 23.98, 0.01)) {
|
|
format = TIMECODE_FPS2398;
|
|
} else if (Xsync_feq(freq, 24, 0.01)) {
|
|
format = TIMECODE_FPS2400;
|
|
} else if (Xsync_feq(freq, 25, 0.01)) {
|
|
format = TIMECODE_FPS2500;
|
|
} else if (Xsync_feq(freq, 29.97, 0.01)) {
|
|
if (bit10) {
|
|
format = TIMECODE_FPS2997Drop;
|
|
} else {
|
|
format = TIMECODE_FPS2997;
|
|
}
|
|
} else if (Xsync_feq(freq, 30, 0.01)) {
|
|
format = TIMECODE_FPS3000;
|
|
} else {
|
|
format = TIMECODE_NONE;
|
|
}
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
template <typename T>
|
|
xs_error_code_t _reg_read(uint32_t regadd, T ®value, int32_t overtime_ms = 100) {
|
|
uint32_t regvalue_u32;
|
|
xs_error_code_t ret = reg_read(regadd, regvalue_u32, overtime_ms);
|
|
if (ret == kxs_ec_success) {
|
|
regvalue = (T)regvalue_u32;
|
|
}
|
|
return ret;
|
|
}
|
|
void parseTimecodeMsgAndReport(XsyncNetAdd &from, uint8_t *data, size_t length);
|
|
void parseCameraSyncMsgAndReport(XsyncNetAdd &from, uint8_t *data, size_t length);
|
|
};
|
|
|
|
/*******************************************************************************
|
|
* Xsync *
|
|
*******************************************************************************/
|
|
|
|
Xsync &Xsync::Ins() {
|
|
static Xsync xsync;
|
|
return xsync;
|
|
}
|
|
|
|
xs_error_code_t Xsync::readSn(string &sn) {
|
|
uint32_t sn0;
|
|
uint32_t sn1;
|
|
uint32_t sn2;
|
|
|
|
DO_XSYNC(reg_read(reg::ksn_id0, sn0));
|
|
DO_XSYNC(reg_read(reg::ksn_id1, sn1));
|
|
DO_XSYNC(reg_read(reg::ksn_id2, sn2));
|
|
|
|
char buf[128] = {0};
|
|
sprintf(buf, "%02d%02d%04d", sn0, sn1, sn2);
|
|
sn = buf;
|
|
|
|
return kxs_ec_success;
|
|
}
|
|
xs_error_code_t Xsync::readMac(string &mac) {
|
|
// mac = "";
|
|
uint32_t mac0;
|
|
uint32_t mac1;
|
|
|
|
DO_XSYNC(reg_read(reg::kmac0, mac0));
|
|
DO_XSYNC(reg_read(reg::kmac1, mac1));
|
|
|
|
char buf[128] = {0};
|
|
sprintf(buf, "%02x-%02x-%02x-%02x-%02x-%02x", (mac0 >> 0) & 0xff, (mac0 >> 8) & 0xff, (mac0 >> 16) & 0xff, (mac0 >> 24) & 0xff, (mac1 >> 0) & 0xff, (mac1 >> 8) & 0xff);
|
|
mac = buf;
|
|
|
|
return kxs_ec_success;
|
|
}
|
|
#if 0
|
|
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_);
|
|
|
|
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 = {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) {
|
|
return ecode;
|
|
}
|
|
|
|
XsyncNetAdd fromadd;
|
|
while (true) {
|
|
ecode = m_xsync_reg_udp->receive((char *)rx_data, buffersize, fromadd, overtime_ms);
|
|
if (ecode != kxs_ec_success) {
|
|
return ecode;
|
|
}
|
|
if (rx_data->index != cmd->index) {
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return (xs_error_code_t)rx_data->data[0];
|
|
}
|
|
#endif
|
|
|
|
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_);
|
|
|
|
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++;
|
|
|
|
rxContext.clear();
|
|
rxContext.setWait(true, cmd->index);
|
|
|
|
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) {
|
|
return ecode;
|
|
}
|
|
|
|
for (int32_t i = 0; i < overtime_ms; i++) {
|
|
if (rxContext.isReady()) {
|
|
memcpy(rx_data, rxContext.data(), rxContext.size());
|
|
return (xs_error_code_t)rx_data->data[0];
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
|
}
|
|
return kxs_ec_overtime;
|
|
}
|
|
|
|
xs_error_code_t Xsync::reg_write(uint32_t regadd, uint32_t regvalue, int32_t overtime_ms) { //
|
|
uint32_t readbak = 0;
|
|
return reg_write(regadd, regvalue, readbak, overtime_ms);
|
|
}
|
|
xs_error_code_t Xsync::reg_write(uint32_t regadd, uint32_t regvalue, uint32_t ®backvalue, 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 ®value, 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> ®values, 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;
|
|
}
|
|
|
|
xs_error_code_t Xsync::readtimecode(uint32_t reg0, uint32_t reg1, XsyncTimecode_t &timecode) {
|
|
uint32_t readbak = 0;
|
|
xs_error_code_t ecode = kxs_ec_success;
|
|
|
|
uint32_t tc0 = 0;
|
|
uint32_t tc1 = 0;
|
|
|
|
ecode = reg_read(reg0, tc0, 10);
|
|
if (ecode != kxs_ec_success) return ecode;
|
|
ecode = reg_read(reg1, tc1, 10);
|
|
if (ecode != kxs_ec_success) return ecode;
|
|
|
|
Timecode64_t tc64 = {0};
|
|
tc64.tc0 = tc0;
|
|
tc64.tc1 = tc1;
|
|
|
|
timecode = timecode64ToXsyncTimeCode(tc64);
|
|
return ecode;
|
|
}
|
|
xs_error_code_t Xsync::writetimecode(uint32_t reg0, uint32_t reg1, XsyncTimecode_t timecode) {
|
|
uint32_t readbak = 0;
|
|
xs_error_code_t ecode = kxs_ec_success;
|
|
|
|
Timecode64_t tc64 = timecodeTo64(timecode);
|
|
|
|
ecode = reg_write(reg0, tc64.tc0, readbak, 10);
|
|
if (ecode != kxs_ec_success) return ecode;
|
|
ecode = reg_write(reg1, tc64.tc1, readbak, 10);
|
|
if (ecode != kxs_ec_success) return ecode;
|
|
|
|
return ecode;
|
|
}
|
|
|
|
xs_error_code_t Xsync::readfreq(uint32_t reg, float &freqfloat) {
|
|
uint32_t freq_cnt = 0;
|
|
DO_XSYNC(reg_read(reg, freq_cnt));
|
|
if (freq_cnt == 0) {
|
|
freqfloat = 0;
|
|
}
|
|
|
|
if (freq_cnt != 0) {
|
|
uint32_t freq_100x = ((1.0 / (freq_cnt * 1.0 / (10 * 1000 * 1000))) * 100 + 0.5); //+0.5是因为c++ 小数强转成整数时是取整，而非四舍五入
|
|
// ZLOGI(TAG, "freq_10x %f", freq_10x);
|
|
freqfloat = freq_100x / 100.0;
|
|
} else {
|
|
freqfloat = 0;
|
|
}
|
|
return kxs_ec_success;
|
|
}
|
|
|
|
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;
|
|
|
|
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);
|
|
}
|
|
|
|
xs_error_code_t Xsync::generatorNewMac() { return doaction(xsync_stm32_action_generator_new_mac, 0, nullptr, 2000); }
|
|
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); }
|
|
|
|
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(reg::kstm32_action_val0, actionval, readbak);
|
|
if (ecode != kxs_ec_success) return ecode;
|
|
|
|
ecode = reg_write(reg::kstm32_action0, action, readbak, overtime_ms);
|
|
if (ecode != kxs_ec_success) return ecode;
|
|
if (ackreturn) *ackreturn = readbak;
|
|
return ecode;
|
|
}
|
|
|
|
namespace xsync {
|
|
void XsyncInit(I_XSUDPFactory *xsync_udp_factory) { g_xsync_udp_factory = xsync_udp_factory; }
|
|
IXsync *XsyncIns() { return &Xsync::Ins(); }
|
|
} // namespace xsync
|