Gatsby
2fc5941f0f
- Replaced unsigned char, int and long long with uint8_t int32_t and int64_t for platform independence - Removed <algorithm> dependency, implemented custom alternatives
549 lines
20 KiB
C++
549 lines
20 KiB
C++
#include <string>
|
|
#include <cstring>
|
|
#include <map>
|
|
#include <vector>
|
|
#include "defs.h"
|
|
#include "cx9261adriver.h"
|
|
#include "cx9261adriver_c.h"
|
|
|
|
using namespace CX9261A;
|
|
|
|
// Macro for convert enumerate
|
|
#define DEFINE_ENUM_CONVERTER(enum_type) \
|
|
static inline enum_type convertToCxx(CX9261A_##enum_type value) { \
|
|
return static_cast<enum_type>(value); \
|
|
}
|
|
|
|
// Macro for functions without parameters
|
|
#define DEFINE_SIMPLE_C_WRAPPER(func_name, return_type) \
|
|
return_type CX9261A_##func_name() { \
|
|
return func_name(); \
|
|
}
|
|
|
|
// Macro for functions with one passthrough parameter
|
|
#define DEFINE_C_WRAPPER_ONE_PASS(func_name, param_type, return_type) \
|
|
return_type CX9261A_##func_name(param_type param) { \
|
|
return func_name(param); \
|
|
}
|
|
|
|
// Macro for functions with two passthrough parameter
|
|
#define DEFINE_C_WRAPPER_TWO_PASS(func_name, param0_type, param1_type, return_type) \
|
|
return_type CX9261A_##func_name(param0_type param0, param1_type param1) { return func_name(param0, param1); }
|
|
|
|
// Macro for functions with one convert parameter
|
|
#define DEFINE_C_WRAPPER_ONE_PTR_CONVERT(func_name, param_type, return_type) \
|
|
return_type CX9261A_##func_name(const CX9261A_##param_type *param) { \
|
|
return func_name(convertToCxx(*param)); \
|
|
}
|
|
|
|
// Macro for functions with one convert parameter
|
|
#define DEFINE_C_WRAPPER_ONE_CONVERT(func_name, param_type, return_type) \
|
|
return_type CX9261A_##func_name(const CX9261A_##param_type param) { \
|
|
return func_name(convertToCxx(param)); \
|
|
}
|
|
|
|
// Macro for functions with one convert parameter
|
|
#define DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_CONVERT(func_name, param0_type, param1_type, return_type) \
|
|
return_type CX9261A_##func_name(const CX9261A_##param0_type *param0, const CX9261A_##param1_type param1) { \
|
|
return func_name(convertToCxx(*param0), convertToCxx(param1)); \
|
|
}
|
|
|
|
// Macro for functions with one pass one convert parameter
|
|
#define DEFINE_C_WRAPPER_ONE_PASS_ONE_CONVERT(func_name, param0_type, param1_type, return_type) \
|
|
return_type CX9261A_##func_name(param0_type param0, const CX9261A_##param1_type param1) { \
|
|
return func_name(param0, convertToCxx(param1)); \
|
|
}
|
|
|
|
// Macro for functions with one pass one convert parameter
|
|
#define DEFINE_C_WRAPPER_ONE_PASS_ONE_PTR_CONVERT(func_name, param0_type, param1_type, return_type) \
|
|
return_type CX9261A_##func_name(param0_type param0, const CX9261A_##param1_type *param1) { \
|
|
return func_name(param0, convertToCxx(*param1)); \
|
|
}
|
|
|
|
// Macro for functions with one convert one pass parameter
|
|
#define DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_PASS(func_name, param0_type, param1_type, return_type) \
|
|
return_type CX9261A_##func_name(const CX9261A_##param0_type *param0, param1_type param1) { \
|
|
return func_name(convertToCxx(*param0), param1); \
|
|
}
|
|
|
|
// Macro for functions with one pass two convert parameter
|
|
#define DEFINE_C_WRAPPER_ONE_PASS_TWO_CONVERT(func_name, param0_type, param1_type, param2_type, return_type) \
|
|
return_type CX9261A_##func_name(param0_type param0, const CX9261A_##param1_type param1, const CX9261A_##param2_type param2) { \
|
|
return func_name(param0, convertToCxx(param1), convertToCxx(param2)); \
|
|
}
|
|
|
|
|
|
DEFINE_ENUM_CONVERTER(WorkMode)
|
|
DEFINE_ENUM_CONVERTER(TrMode)
|
|
DEFINE_ENUM_CONVERTER(PortMode)
|
|
DEFINE_ENUM_CONVERTER(IOMode)
|
|
DEFINE_ENUM_CONVERTER(LoSource)
|
|
DEFINE_ENUM_CONVERTER(RxChannel)
|
|
DEFINE_ENUM_CONVERTER(TxChannel)
|
|
DEFINE_ENUM_CONVERTER(PowerMode)
|
|
DEFINE_ENUM_CONVERTER(NCOMode)
|
|
DEFINE_ENUM_CONVERTER(TemperatureComp)
|
|
DEFINE_ENUM_CONVERTER(CalibMethod)
|
|
DEFINE_ENUM_CONVERTER(DCCalibMethod)
|
|
|
|
// Convert AGCPDT from C to C++
|
|
static inline AGCPDT convertToCxx(const CX9261A_AGCPDT& pdt) {
|
|
AGCPDT result;
|
|
result.pdtN = pdt.pdtN;
|
|
result.pdtM = pdt.pdtM;
|
|
return result;
|
|
}
|
|
|
|
// Convert AGCLMT from C to C++
|
|
static inline AGCLMT convertToCxx(const CX9261A_AGCLMT& lmt) {
|
|
AGCLMT result;
|
|
result.count = lmt.count;
|
|
result.threshold1 = lmt.threshold1;
|
|
result.threshold2 = lmt.threshold2;
|
|
result.threshold3 = lmt.threshold3;
|
|
result.threshold4 = lmt.threshold4;
|
|
return result;
|
|
}
|
|
|
|
// Convert AGCDIG from C to C++
|
|
static inline AGCDIG convertToCxx(const CX9261A_AGCDIG& dig) {
|
|
AGCDIG result;
|
|
result.count = dig.count;
|
|
result.threshold1 = dig.threshold1;
|
|
result.threshold2 = dig.threshold2;
|
|
result.threshold3 = dig.threshold3;
|
|
result.threshold4 = dig.threshold4;
|
|
return result;
|
|
}
|
|
|
|
// Convert AGC from C to C++
|
|
static AGC convertToCxx(const CX9261A_AGC& agc) {
|
|
AGC result;
|
|
result.mode = agc.mode;
|
|
result.pdt = convertToCxx(agc.pdt);
|
|
result.lmt = convertToCxx(agc.lmt);
|
|
result.dig = convertToCxx(agc.dig);
|
|
return result;
|
|
}
|
|
|
|
// Convert Clock from C to C++
|
|
static Clock convertToCxx(const CX9261A_Clock& clock) {
|
|
Clock result;
|
|
result.ref = clock.ref;
|
|
result.adc = clock.adc;
|
|
result.refDiv = clock.refDiv;
|
|
result.bbUseIntDiv = clock.bbUseIntDiv;
|
|
result.refDoubler = clock.refDoubler;
|
|
return result;
|
|
}
|
|
|
|
// Convert Calib from C to C++
|
|
static Calib convertToCxx(const CX9261A_Calib& c) {
|
|
Calib result;
|
|
result.calibDC = c.calibDC;
|
|
result.dcTrackingLength = c.dcTrackingLength;
|
|
result.dcHighPassFactor = c.dcHighPassFactor;
|
|
result.rx1CalibPll = c.rx1CalibPll;
|
|
result.rx2CalibPll = c.rx2CalibPll;
|
|
result.rx3CalibPll = c.rx3CalibPll;
|
|
result.tx1CalibPll = c.tx1CalibPll;
|
|
result.tx2CalibPll = c.tx2CalibPll;
|
|
result.f0 = c.f0;
|
|
result.dcCalibMethod = convertToCxx(c.dcCalibMethod);
|
|
result.rxMethod = convertToCxx(c.rxMethod);
|
|
result.txMethod = convertToCxx(c.txMethod);
|
|
if(MAX_MULTI_POINTS < c.numRxPoint) {
|
|
LOGGING("Rx多点校准的频率校准数量超出限制 MAX_MULTI_POINTS");
|
|
exit(-1);
|
|
}
|
|
if(MAX_MULTI_POINTS < c.numTxPoint) {
|
|
LOGGING("Tx多点校准的频率校准数量超出限制 MAX_MULTI_POINTS");
|
|
exit(-1);
|
|
}
|
|
result.rxMultiPoints.resize(c.numRxPoint);
|
|
result.txMultiPoints.resize(c.numTxPoint);
|
|
std::memcpy(result.rxMultiPoints.data(), c.rxMultiPoints, c.numRxPoint * sizeof(double));
|
|
std::memcpy(result.txMultiPoints.data(), c.txMultiPoints, c.numTxPoint * sizeof(double));
|
|
return result;
|
|
}
|
|
|
|
// Convert PllSource from C to C++
|
|
static PllSource convertToCxx(const CX9261A_PllSource& src) {
|
|
PllSource result;
|
|
result.rxUseExt = src.rxUseExt;
|
|
result.txUseExt = src.txUseExt;
|
|
result.rx1Source = convertToCxx(src.rx1Source);
|
|
result.rx2Source = convertToCxx(src.rx2Source);
|
|
result.rx3Source = convertToCxx(src.rx3Source);
|
|
result.tx1Source = convertToCxx(src.tx1Source);
|
|
result.tx2Source = convertToCxx(src.tx2Source);
|
|
return result;
|
|
}
|
|
|
|
// Convert PllFreq from C to C++
|
|
static PllFreq convertToCxx(const CX9261A_PllFreq& freq) {
|
|
PllFreq result;
|
|
result.pll1Freq = freq.pll1Freq;
|
|
result.pll2Freq = freq.pll2Freq;
|
|
result.pll3Freq = freq.pll3Freq;
|
|
result.pll4Freq = freq.pll4Freq;
|
|
result.pll5Freq = freq.pll5Freq;
|
|
result.rxExtFreq = freq.rxExtFreq;
|
|
result.txExtFreq = freq.txExtFreq;
|
|
return result;
|
|
}
|
|
|
|
// Convert Interface from C to C++
|
|
static Interface convertToCxx(const CX9261A_Interface& iface) {
|
|
Interface result;
|
|
result.workMode = convertToCxx(iface.workMode);
|
|
result.trMode = convertToCxx(iface.trMode);
|
|
result.portMode = convertToCxx(iface.portMode);
|
|
result.ioMode = convertToCxx(iface.ioMode);
|
|
return result;
|
|
}
|
|
|
|
// Convert TxNCO from C to C++
|
|
static TxNCO convertToCxx(const CX9261A_TxNCO& nco) {
|
|
TxNCO result;
|
|
result.txUseBist = nco.txUseBist;
|
|
result.txNCOFreq = nco.txNCOFreq;
|
|
return result;
|
|
}
|
|
|
|
// Convert RxNCO from C to C++
|
|
static RxNCO convertToCxx(const CX9261A_RxNCO& nco) {
|
|
RxNCO result;
|
|
result.rxUseBist = nco.rxUseBist;
|
|
result.rxNCOBypass = nco.rxNCOBypass;
|
|
result.rxNCOUpward = nco.rxNCOUpward;
|
|
result.rxNCOMaster = nco.rxNCOMaster;
|
|
result.rxNCOFreq = nco.rxNCOFreq;
|
|
return result;
|
|
}
|
|
|
|
// Convert RxConfig from C to C++
|
|
static RxConfig convertToCxx(const CX9261A_RxConfig& config) {
|
|
RxConfig result;
|
|
result.bandwidth = config.bandwidth;
|
|
result.tia = config.tia;
|
|
result.mixer = config.mixer;
|
|
return result;
|
|
}
|
|
|
|
// Convert TxConfig from C to C++
|
|
static TxConfig convertToCxx(const CX9261A_TxConfig& config) {
|
|
TxConfig result;
|
|
result.bandwidth = config.bandwidth;
|
|
result.mixer = config.mixer;
|
|
return result;
|
|
}
|
|
|
|
// Convert Filters from C to C++
|
|
static Filters convertToCxx(const CX9261A_Filters& filters) {
|
|
Filters result;
|
|
result.fir = filters.fir;
|
|
result.hbf1 = filters.hbf1;
|
|
result.hbf2 = filters.hbf2;
|
|
result.hbf3 = filters.hbf3;
|
|
result.cic = filters.cic;
|
|
return result;
|
|
}
|
|
|
|
// Convert Power from C to C++
|
|
static Power convertToCxx(const CX9261A_Power& power) {
|
|
Power result;
|
|
result.dig_tx2 = power.dig_tx2;
|
|
result.dig_tx1 = power.dig_tx1;
|
|
result.dig_rx3 = power.dig_rx3;
|
|
result.dig_rx2 = power.dig_rx2;
|
|
result.dig_rx1 = power.dig_rx1;
|
|
result.fref1_rx = power.fref1_rx;
|
|
result.auxadc2 = power.auxadc2;
|
|
result.auxadc1 = power.auxadc1;
|
|
result.auxdac = power.auxdac;
|
|
result.temp_sensor = power.temp_sensor;
|
|
result.bgr = power.bgr;
|
|
result.exlo = power.exlo;
|
|
result.tx2 = power.tx2;
|
|
result.tx1 = power.tx1;
|
|
result.rx3 = power.rx3;
|
|
result.rx2 = power.rx2;
|
|
result.rx1 = power.rx1;
|
|
result.pll5_ldo = power.pll5_ldo;
|
|
result.pll5 = power.pll5;
|
|
result.pll4_ldo = power.pll4_ldo;
|
|
result.pll4 = power.pll4;
|
|
result.pll3_ldo = power.pll3_ldo;
|
|
result.pll3 = power.pll3;
|
|
result.pll2_ldo = power.pll2_ldo;
|
|
result.pll2 = power.pll2;
|
|
result.pll1_ldo = power.pll1_ldo;
|
|
result.pll1 = power.pll1;
|
|
result.bbpll = power.bbpll;
|
|
return result;
|
|
}
|
|
|
|
static PowerManagement convertToCxx(const CX9261A_PowerManagement& pwMgmt) {
|
|
PowerManagement result;
|
|
result.powerMode = convertToCxx(pwMgmt.powerMode);
|
|
result.rxPower = convertToCxx(pwMgmt.rxPower);
|
|
result.txPower = convertToCxx(pwMgmt.txPower);
|
|
result.fddPower = convertToCxx(pwMgmt.fddPower);
|
|
return result;
|
|
}
|
|
|
|
static CX9261A_CalibPredis convertToC(const CalibPredis& cp) {
|
|
CX9261A_CalibPredis result;
|
|
result.bHigh = cp.bHigh;
|
|
result.bLow = cp.bLow;
|
|
result.cHigh = cp.cHigh;
|
|
result.cLow = cp.cLow;
|
|
result.dciHigh = cp.dciHigh;
|
|
result.dciLow = cp.dciLow;
|
|
result.dcqHigh = cp.dcqHigh;
|
|
result.dcqLow = cp.dcqLow;
|
|
return result;
|
|
}
|
|
|
|
static CX9261AConfiguration convertToCxx(const CX9261A_CX9261AConfiguration& config) {
|
|
CX9261AConfiguration result;
|
|
result.tempComp = convertToCxx(config.tempComp);
|
|
result.agc = convertToCxx(config.agc);
|
|
result.interface = convertToCxx(config.interface);
|
|
result.clock = convertToCxx(config.clock);
|
|
result.pllSource = convertToCxx(config.pllSource);
|
|
result.calib = convertToCxx(config.calib);
|
|
result.pllFreq = convertToCxx(config.pllFreq);
|
|
result.txNco = convertToCxx(config.txNco);
|
|
result.rxNco = convertToCxx(config.rxNco);
|
|
result.rx1Config = convertToCxx(config.rx1Config);
|
|
result.rx2Config = convertToCxx(config.rx2Config);
|
|
result.rx3Config = convertToCxx(config.rx3Config);
|
|
result.tx1Config = convertToCxx(config.tx1Config);
|
|
result.tx2Config = convertToCxx(config.tx2Config);
|
|
result.rxFilters = convertToCxx(config.rxFilters);
|
|
result.txFilters = convertToCxx(config.txFilters);
|
|
result.powerManagement = convertToCxx(config.powerManagement);
|
|
if(MAX_NUM_FIR < config.numRxFIR) {
|
|
LOGGING("Rx FIR滤波器系数阶数超出限制 MAX_MULTI_POINTS");
|
|
exit(-1);
|
|
}
|
|
if(MAX_NUM_FIR < config.numTxFIR) {
|
|
LOGGING("Rx FIR滤波器系数阶数超出限制 MAX_MULTI_POINTS");
|
|
exit(-1);
|
|
}
|
|
result.rxFIRCoe.resize(config.numRxFIR);
|
|
result.txFIRCoe.resize(config.numTxFIR);
|
|
std::memcpy(result.rxFIRCoe.data(), config.rxFIRCoe, config.numRxFIR);
|
|
std::memcpy(result.txFIRCoe.data(), config.txFIRCoe, config.numTxFIR);
|
|
return result;
|
|
}
|
|
|
|
DEFINE_SIMPLE_C_WRAPPER(initialChip, void)
|
|
DEFINE_SIMPLE_C_WRAPPER(initialBBPLL, void)
|
|
DEFINE_SIMPLE_C_WRAPPER(initialPLL1, void)
|
|
DEFINE_SIMPLE_C_WRAPPER(initialPLL2, void)
|
|
DEFINE_SIMPLE_C_WRAPPER(initialPLL3, void)
|
|
DEFINE_SIMPLE_C_WRAPPER(initialPLL4, void)
|
|
DEFINE_SIMPLE_C_WRAPPER(initialPLL5, void)
|
|
DEFINE_SIMPLE_C_WRAPPER(configFlashCalib, void)
|
|
DEFINE_SIMPLE_C_WRAPPER(afcBBPll, bool)
|
|
DEFINE_SIMPLE_C_WRAPPER(afcPll1, bool)
|
|
DEFINE_SIMPLE_C_WRAPPER(afcPll2, bool)
|
|
DEFINE_SIMPLE_C_WRAPPER(afcPll3, bool)
|
|
DEFINE_SIMPLE_C_WRAPPER(afcPll4, bool)
|
|
DEFINE_SIMPLE_C_WRAPPER(afcPll5, bool)
|
|
DEFINE_SIMPLE_C_WRAPPER(waitRxTSTFinished, bool)
|
|
|
|
DEFINE_C_WRAPPER_ONE_PASS(configAGCMode, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configRISCV, bool, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configADCCalib, double, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configDcTrackingLength, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configDcHighPassFactor, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configTxFIR, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configTxHBF1, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configTxHBF2, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configTxHBF3, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configTxCIC, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configTxBIST, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configRxFIR, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configRxHBF1, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configRxHBF2, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configRxHBF3, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configRxCIC, int, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS(configRxMixer, int, void)
|
|
|
|
DEFINE_C_WRAPPER_TWO_PASS(txBisectionQecCalib, double, double, void);
|
|
DEFINE_C_WRAPPER_TWO_PASS(txBisectionDcCalib, double, double, void)
|
|
DEFINE_C_WRAPPER_TWO_PASS(configTxNcoFreq, double, double, void);
|
|
DEFINE_C_WRAPPER_TWO_PASS(configRxNcoFreq, double, double, void);
|
|
DEFINE_C_WRAPPER_TWO_PASS(configRefDoubler, double, double, void);
|
|
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(initialPowerConfig, CX9261AConfiguration, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configBBPLL, CX9261AConfiguration, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configAGCPDT, AGCPDT, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configAGCLMT, AGCLMT, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configAGCDIG, AGCDIG, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configAGC, AGC, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(preparePowerForRxCalib, PllSource, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configDcCalib, Calib, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configCalibMethod, Calib, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(preparePowerForTxCalib, PllSource, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(preparePllForTxCalib, CX9261AConfiguration, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(txCalib, CX9261AConfiguration, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configQecCalib, CX9261AConfiguration, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configInterface, Interface, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configPllSource, PllSource, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configTxFilters, Filters, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configRxFilters, Filters, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT(configFPGA, Interface, void)
|
|
|
|
DEFINE_C_WRAPPER_ONE_CONVERT(configTemperatureCompensation, TemperatureComp, void)
|
|
DEFINE_C_WRAPPER_ONE_CONVERT(rxTSTCalib, RxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_CONVERT(configRxNcoMode, NCOMode, void)
|
|
DEFINE_C_WRAPPER_ONE_CONVERT(configRxNcoMS, NCOMode, void)
|
|
DEFINE_C_WRAPPER_ONE_CONVERT(configPowerMode, PowerMode, void)
|
|
DEFINE_C_WRAPPER_ONE_CONVERT(initialRxChannel, RxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_CONVERT(initialTxChannel, TxChannel, void)
|
|
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_CONVERT(preparePllForRxCalib, CX9261AConfiguration, RxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_CONVERT(txTSTCalib, CX9261AConfiguration, TxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_CONVERT(rxCalib, CX9261AConfiguration, RxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_CONVERT(configPowerPins, Power, PowerMode, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_CONVERT(configRxChannel, RxConfig, RxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_CONVERT(configTxChannel, TxConfig, TxChannel, void)
|
|
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_PASS(configTxNco, TxNCO, double, void);
|
|
DEFINE_C_WRAPPER_ONE_PTR_CONVERT_ONE_PASS(configRxNco, RxNCO, double, void);
|
|
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_PTR_CONVERT(configPll1, double, Clock, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_PTR_CONVERT(configPll2, double, Clock, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_PTR_CONVERT(configPll3, double, Clock, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_PTR_CONVERT(configPll4, double, Clock, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_PTR_CONVERT(configPll5, double, Clock, void)
|
|
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_CONVERT(rxDelayCalib, double, RxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_CONVERT(configRxBandwidth, double, RxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_CONVERT(configRxTIA, int, RxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_CONVERT(configTxBandwidth, int, TxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_CONVERT(configTxMixer, int, TxChannel, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_ONE_CONVERT(configTxChannelFrequency, double, TxChannel, void)
|
|
|
|
DEFINE_C_WRAPPER_ONE_PASS_TWO_CONVERT(saveRxCalibPredis, unsigned char, RxChannel, LoSource, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_TWO_CONVERT(loadRxCalibPredis, unsigned char, RxChannel, LoSource, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_TWO_CONVERT(saveTxCalibPredis, unsigned char, TxChannel, LoSource, void)
|
|
DEFINE_C_WRAPPER_ONE_PASS_TWO_CONVERT(loadTxCalibPredis, unsigned char, TxChannel, LoSource, void)
|
|
|
|
|
|
void CX9261A_beforeQecState(QecStatePair* buff, size_t *len) {
|
|
std::map<int, int> state = beforeQecState();
|
|
*len = 0;
|
|
for (const auto&[first, second]: state) {
|
|
buff[*len].first = first;
|
|
buff[*len].second = second;
|
|
(*len)++;
|
|
}
|
|
}
|
|
|
|
void CX9261A_restoreQecState(QecStatePair* buff, size_t len) {
|
|
std::map<int, int> state;
|
|
for (std::size_t i = 0; i < len; ++i) {
|
|
state[buff[i].first] = buff[i].second;
|
|
}
|
|
restoreQecState(state);
|
|
}
|
|
|
|
|
|
void CX9261A_configRxMultiPointsQec(const CX9261A_CX9261AConfiguration *config, CX9261A_RxChannel chan, const double *points, size_t len) {
|
|
std::vector<double> points_vec(points, points+len);
|
|
configRxMultiPointsQec(convertToCxx(*config), points_vec, convertToCxx(chan));
|
|
}
|
|
|
|
void CX9261A_configTxMultiPointsQec(const CX9261A_CX9261AConfiguration *config, const double *points, size_t len) {
|
|
std::vector<double> points_vec(points, points+len);
|
|
configTxMultiPointsQec(convertToCxx(*config), points_vec);
|
|
}
|
|
|
|
void CX9261A_configRxFIRCoe(const double *coe, size_t len) {
|
|
std::vector<double> coe_vec(coe, coe+len);
|
|
configRxFIRCoe(coe_vec);
|
|
}
|
|
|
|
void CX9261A_configTxFIRCoe(const double *coe, size_t len) {
|
|
std::vector<double> coe_vec(coe, coe+len);
|
|
configTxFIRCoe(coe_vec);
|
|
}
|
|
|
|
CX9261A_CalibPredis CX9261A_readRxCalibPredis(CX9261A_RxChannel chan) {
|
|
return convertToC(readRxCalibPredis(convertToCxx(chan)));
|
|
}
|
|
|
|
CX9261A_CalibPredis CX9261A_readTxCalibPredis(CX9261A_TxChannel chan) {
|
|
return convertToC(readTxCalibPredis(convertToCxx(chan)));
|
|
}
|
|
|
|
|
|
static CX9261A_LoggingFunc loggingFunc = NULL;
|
|
static CX9261A_WriteSpiFunc writeSpiFunc = NULL;
|
|
static CX9261A_ReadSpiFunc readSpiFunc = NULL;
|
|
static CX9261A_PauseFunc pauseFunc = NULL;
|
|
static CX9261A_SetPinFunc setPinFunc = NULL;
|
|
|
|
// 设置函数指针
|
|
void CX9261A_setLoggingFunc(CX9261A_LoggingFunc func) {
|
|
loggingFunc = func;
|
|
}
|
|
|
|
void CX9261A_setWriteSpiFunc(CX9261A_WriteSpiFunc func) {
|
|
writeSpiFunc = func;
|
|
}
|
|
|
|
void CX9261A_setReadSpiFunc(CX9261A_ReadSpiFunc func) {
|
|
readSpiFunc = func;
|
|
}
|
|
|
|
void CX9261A_setPauseFunc(CX9261A_PauseFunc func) {
|
|
pauseFunc = func;
|
|
}
|
|
|
|
void CX9261A_setSetPinFunc(CX9261A_SetPinFunc func) {
|
|
setPinFunc = func;
|
|
}
|
|
|
|
#ifdef USE_LOGGING
|
|
void CX9261A::logging(const std::string& msg) {
|
|
if(loggingFunc == NULL) {
|
|
exit(-1);
|
|
}
|
|
return loggingFunc(msg.c_str());
|
|
}
|
|
#endif
|
|
|
|
void CX9261A::writeSpi(std::uint16_t address, std::uint8_t value) {
|
|
if(writeSpiFunc == NULL) {
|
|
exit(-1);
|
|
}
|
|
return writeSpiFunc(address, value);
|
|
}
|
|
|
|
std::uint8_t CX9261A::readSpi(std::uint16_t address) {
|
|
if(readSpiFunc == NULL) {
|
|
exit(-1);
|
|
}
|
|
return readSpiFunc(address);
|
|
}
|
|
|
|
void CX9261A::pause(double ms) {
|
|
if(pauseFunc == NULL) {
|
|
exit(-1);
|
|
}
|
|
return pauseFunc(ms);
|
|
}
|
|
|
|
void CX9261A::setPin(std::uint32_t pin, bool value) {
|
|
if(setPinFunc == NULL) {
|
|
exit(-1);
|
|
}
|
|
return setPinFunc(pin, value);
|
|
} |