awe/kamil_adc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
0e90ba6a1baabb43622b290c5171b1bbb3008fe9
kamil_adc/main.cpp
kamil 0e90ba6a1b initial commit
2026-04-07 17:22:17 +03:00

1001 lines
38 KiB
C++
Raw Blame History

#ifdef _WIN32
#ifndef NOMINMAX
#define NOMINMAX
#endif
#endif
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4995)
#endif
#include "x502api.h"
#include "e502api.h"
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#include <algorithm>
#include <array>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <optional>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
namespace {
enum class StopMode {
TargetFrames,
DiSyn2Rise,
DiSyn2Fall
};
struct Config {
std::string serial;
std::optional<uint32_t> ip_addr;
uint32_t mode = X502_LCH_MODE_DIFF;
uint32_t range = X502_ADC_RANGE_5;
uint32_t ch1 = 2;
uint32_t ch2 = 3;
double sample_clock_hz = 2000000.0;
double duration_ms = 40.0;
uint32_t sync_mode = X502_SYNC_EXTERNAL_MASTER;
uint32_t sync_start_mode = X502_SYNC_DI_SYN1_RISE;
StopMode stop_mode = StopMode::TargetFrames;
uint32_t recv_block_words = 8192;
uint32_t recv_timeout_ms = 100;
uint32_t start_wait_ms = 10000;
uint32_t input_buffer_words = 262144;
uint32_t input_step_words = 8192;
bool pullup_syn1 = false;
bool pullup_syn2 = false;
bool pulldown_conv_in = false;
bool pulldown_start_in = false;
std::string csv_path = "capture.csv";
std::string svg_path = "capture.svg";
};
[[noreturn]] void fail(const std::string& message) {
throw std::runtime_error(message);
}
std::string trim_copy(const std::string& text) {
const auto first = text.find_first_not_of(" \t\r\n");
if (first == std::string::npos) {
return {};
}
const auto last = text.find_last_not_of(" \t\r\n");
return text.substr(first, last - first + 1);
}
bool starts_with(const std::string& value, const std::string& prefix) {
return value.rfind(prefix, 0) == 0;
}
uint32_t parse_u32(const std::string& text, const std::string& field_name) {
const std::string clean = trim_copy(text);
char* end = nullptr;
const auto value = std::strtoull(clean.c_str(), &end, 0);
if ((end == clean.c_str()) || (*end != '\0') || (value > std::numeric_limits<uint32_t>::max())) {
fail("Invalid integer for " + field_name + ": " + text);
}
return static_cast<uint32_t>(value);
}
double parse_double(const std::string& text, const std::string& field_name) {
const std::string clean = trim_copy(text);
char* end = nullptr;
const double value = std::strtod(clean.c_str(), &end);
if ((end == clean.c_str()) || (*end != '\0') || !std::isfinite(value)) {
fail("Invalid floating point value for " + field_name + ": " + text);
}
return value;
}
uint32_t parse_ipv4(const std::string& text) {
std::array<uint32_t, 4> parts{};
std::stringstream ss(text);
std::string token;
for (std::size_t i = 0; i < parts.size(); ++i) {
if (!std::getline(ss, token, '.')) {
fail("Invalid IPv4 address: " + text);
}
parts[i] = parse_u32(token, "ip");
if (parts[i] > 255) {
fail("IPv4 byte out of range: " + token);
}
}
if (std::getline(ss, token, '.')) {
fail("Invalid IPv4 address: " + text);
}
return (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3];
}
std::string ipv4_to_string(uint32_t ip_addr) {
std::ostringstream out;
out << ((ip_addr >> 24) & 0xFF) << '.'
<< ((ip_addr >> 16) & 0xFF) << '.'
<< ((ip_addr >> 8) & 0xFF) << '.'
<< (ip_addr & 0xFF);
return out.str();
}
uint32_t parse_range(const std::string& text) {
const double value = parse_double(text, "range");
if (std::fabs(value - 10.0) < 1e-9) {
return X502_ADC_RANGE_10;
}
if (std::fabs(value - 5.0) < 1e-9) {
return X502_ADC_RANGE_5;
}
if (std::fabs(value - 2.0) < 1e-9) {
return X502_ADC_RANGE_2;
}
if (std::fabs(value - 1.0) < 1e-9) {
return X502_ADC_RANGE_1;
}
if (std::fabs(value - 0.5) < 1e-9) {
return X502_ADC_RANGE_05;
}
if (std::fabs(value - 0.2) < 1e-9) {
return X502_ADC_RANGE_02;
}
fail("Unsupported E-502 range: " + text);
}
double range_to_volts(uint32_t range) {
switch (range) {
case X502_ADC_RANGE_10:
return 10.0;
case X502_ADC_RANGE_5:
return 5.0;
case X502_ADC_RANGE_2:
return 2.0;
case X502_ADC_RANGE_1:
return 1.0;
case X502_ADC_RANGE_05:
return 0.5;
case X502_ADC_RANGE_02:
return 0.2;
default:
fail("Unknown ADC range enum");
}
}
uint32_t parse_mode(const std::string& text) {
const std::string value = trim_copy(text);
if ((value == "comm") || (value == "gnd") || (value == "single_ended")) {
return X502_LCH_MODE_COMM;
}
if ((value == "diff") || (value == "differential")) {
return X502_LCH_MODE_DIFF;
}
fail("Unsupported input mode: " + text);
}
uint32_t parse_sync_mode(const std::string& text) {
const std::string value = trim_copy(text);
if ((value == "conv_in") || (value == "start_in") || (value == "external_master")) {
return X502_SYNC_EXTERNAL_MASTER;
}
if (value == "di_syn1_rise") {
return X502_SYNC_DI_SYN1_RISE;
}
if (value == "di_syn1_fall") {
return X502_SYNC_DI_SYN1_FALL;
}
if (value == "di_syn2_rise") {
return X502_SYNC_DI_SYN2_RISE;
}
if (value == "di_syn2_fall") {
return X502_SYNC_DI_SYN2_FALL;
}
if ((value == "internal") || (value == "immediate")) {
return X502_SYNC_INTERNAL;
}
fail("Unsupported sync mode: " + text);
}
std::string sync_mode_to_string(uint32_t mode, bool for_start) {
switch (mode) {
case X502_SYNC_INTERNAL:
return for_start ? "immediate" : "internal";
case X502_SYNC_EXTERNAL_MASTER:
return for_start ? "start_in" : "conv_in";
case X502_SYNC_DI_SYN1_RISE:
return "di_syn1_rise";
case X502_SYNC_DI_SYN1_FALL:
return "di_syn1_fall";
case X502_SYNC_DI_SYN2_RISE:
return "di_syn2_rise";
case X502_SYNC_DI_SYN2_FALL:
return "di_syn2_fall";
default:
return "unknown";
}
}
StopMode parse_stop_mode(const std::string& text) {
const std::string value = trim_copy(text);
if ((value == "frames") || (value == "duration") || (value == "none")) {
return StopMode::TargetFrames;
}
if (value == "di_syn2_rise") {
return StopMode::DiSyn2Rise;
}
if (value == "di_syn2_fall") {
return StopMode::DiSyn2Fall;
}
fail("Unsupported stop mode: " + text);
}
std::string stop_mode_to_string(StopMode mode) {
switch (mode) {
case StopMode::TargetFrames:
return "target_frames";
case StopMode::DiSyn2Rise:
return "di_syn2_rise";
case StopMode::DiSyn2Fall:
return "di_syn2_fall";
default:
return "unknown";
}
}
bool sync_uses_di_syn1(uint32_t mode) {
return (mode == X502_SYNC_DI_SYN1_RISE) || (mode == X502_SYNC_DI_SYN1_FALL);
}
bool sync_uses_di_syn2(uint32_t mode) {
return (mode == X502_SYNC_DI_SYN2_RISE) || (mode == X502_SYNC_DI_SYN2_FALL);
}
std::string phy_channel_name(uint32_t mode, uint32_t phy_ch) {
if (mode == X502_LCH_MODE_DIFF) {
return "X" + std::to_string(phy_ch + 1) + "-Y" + std::to_string(phy_ch + 1);
}
if (phy_ch < 16) {
return "X" + std::to_string(phy_ch + 1);
}
if (phy_ch < 32) {
return "Y" + std::to_string((phy_ch - 16) + 1);
}
return "CH" + std::to_string(phy_ch);
}
void print_help(const char* exe_name) {
std::cout
<< "Usage:\n"
<< " " << exe_name << " [serial:SN] [ip:192.168.0.10] [ch1:2] [ch2:3]\n"
<< " [mode:diff|comm] [range:5] [clock:conv_in]\n"
<< " [start:di_syn1_rise] [stop:frames] [sample_clock_hz:2000000]\n"
<< " [duration_ms:40] [csv:capture.csv] [svg:capture.svg]\n"
<< " [recv_block:8192] [start_wait_ms:10000]\n"
<< " [pullup_syn1] [pullup_syn2] [pulldown_conv_in] [pulldown_start_in]\n"
<< "\n"
<< "Defaults for E-502:\n"
<< " ch1:2, ch2:3 -> X3-Y3 and X4-Y4\n"
<< " mode:diff -> differential measurement\n"
<< " range:5 -> +/-5 V range\n"
<< " clock:conv_in -> external sample clock on CONV_IN\n"
<< " start:di_syn1_rise-> start on DI_SYN1 rising edge\n"
<< " stop:frames -> stop after duration_ms worth of frames\n"
<< " duration_ms:40 -> capture one 40 ms chirp or max length when stop is external\n"
<< "\n"
<< "Differential physical channel mapping:\n"
<< " 0..15 -> X1-Y1 .. X16-Y16\n"
<< "\n"
<< "Common-ground physical channel mapping:\n"
<< " 0..15 -> X1..X16\n"
<< " 16..31 -> Y1..Y16\n"
<< "\n"
<< "Useful sync lines on E-502:\n"
<< " clock: conv_in | di_syn1_rise | di_syn1_fall | di_syn2_rise | di_syn2_fall\n"
<< " start: immediate | start_in | di_syn1_rise | di_syn1_fall | di_syn2_rise | di_syn2_fall\n"
<< " stop: frames | di_syn2_rise | di_syn2_fall\n"
<< "\n"
<< "Stop on DI_SYN2 is polled asynchronously via X502_AsyncInDig(), so ADC stream stays\n"
<< "ADC-only. For reliable stop detection hold DI_SYN2 active until the program stops.\n"
<< "\n"
<< "Recommended working example:\n"
<< " " << exe_name
<< " clock:di_syn1_rise start:start_in stop:di_syn2_rise sample_clock_hz:2000000"
<< " duration_ms:40 csv:chirp.csv svg:chirp.svg\n";
}
Config parse_args(int argc, char** argv) {
Config cfg;
for (int i = 1; i < argc; ++i) {
const std::string arg = argv[i];
if ((arg == "help") || (arg == "--help") || (arg == "-h")) {
print_help(argv[0]);
std::exit(0);
}
if (arg == "pullup_syn1") {
cfg.pullup_syn1 = true;
continue;
}
if (arg == "pullup_syn2") {
cfg.pullup_syn2 = true;
continue;
}
if (arg == "pulldown_conv_in") {
cfg.pulldown_conv_in = true;
continue;
}
if (arg == "pulldown_start_in") {
cfg.pulldown_start_in = true;
continue;
}
if (starts_with(arg, "serial:")) {
cfg.serial = arg.substr(7);
continue;
}
if (starts_with(arg, "ip:")) {
cfg.ip_addr = parse_ipv4(arg.substr(3));
continue;
}
if (starts_with(arg, "mode:")) {
cfg.mode = parse_mode(arg.substr(5));
continue;
}
if (starts_with(arg, "range:")) {
cfg.range = parse_range(arg.substr(6));
continue;
}
if (starts_with(arg, "ch1:")) {
cfg.ch1 = parse_u32(arg.substr(4), "ch1");
continue;
}
if (starts_with(arg, "ch2:")) {
cfg.ch2 = parse_u32(arg.substr(4), "ch2");
continue;
}
if (starts_with(arg, "clock:")) {
cfg.sync_mode = parse_sync_mode(arg.substr(6));
continue;
}
if (starts_with(arg, "start:")) {
cfg.sync_start_mode = parse_sync_mode(arg.substr(6));
continue;
}
if (starts_with(arg, "stop:")) {
cfg.stop_mode = parse_stop_mode(arg.substr(5));
continue;
}
if (starts_with(arg, "sample_clock_hz:")) {
cfg.sample_clock_hz = parse_double(arg.substr(16), "sample_clock_hz");
continue;
}
if (starts_with(arg, "duration_ms:")) {
cfg.duration_ms = parse_double(arg.substr(12), "duration_ms");
continue;
}
if (starts_with(arg, "recv_block:")) {
cfg.recv_block_words = parse_u32(arg.substr(11), "recv_block");
continue;
}
if (starts_with(arg, "recv_timeout_ms:")) {
cfg.recv_timeout_ms = parse_u32(arg.substr(16), "recv_timeout_ms");
continue;
}
if (starts_with(arg, "start_wait_ms:")) {
cfg.start_wait_ms = parse_u32(arg.substr(14), "start_wait_ms");
continue;
}
if (starts_with(arg, "buffer_words:")) {
cfg.input_buffer_words = parse_u32(arg.substr(13), "buffer_words");
continue;
}
if (starts_with(arg, "step_words:")) {
cfg.input_step_words = parse_u32(arg.substr(11), "step_words");
continue;
}
if (starts_with(arg, "csv:")) {
cfg.csv_path = arg.substr(4);
continue;
}
if (starts_with(arg, "svg:")) {
cfg.svg_path = arg.substr(4);
continue;
}
fail("Unknown argument: " + arg);
}
if (cfg.duration_ms <= 0.0) {
fail("duration_ms must be > 0");
}
if (cfg.sample_clock_hz <= 0.0) {
fail("sample_clock_hz must be > 0");
}
if (cfg.recv_block_words == 0) {
fail("recv_block must be > 0");
}
if (cfg.input_step_words == 0) {
cfg.input_step_words = cfg.recv_block_words;
}
if (cfg.input_buffer_words < cfg.recv_block_words) {
cfg.input_buffer_words = cfg.recv_block_words;
}
if (sync_uses_di_syn1(cfg.sync_mode) && sync_uses_di_syn1(cfg.sync_start_mode)) {
fail("clock and start cannot both use DI_SYN1; use start_in or immediate start");
}
if (sync_uses_di_syn2(cfg.sync_mode) && sync_uses_di_syn2(cfg.sync_start_mode)) {
fail("clock and start cannot both use DI_SYN2; use start_in or immediate start");
}
if ((cfg.stop_mode != StopMode::TargetFrames) && sync_uses_di_syn2(cfg.sync_mode)) {
fail("DI_SYN2 cannot be used simultaneously for clock and stop");
}
if ((cfg.stop_mode != StopMode::TargetFrames) && sync_uses_di_syn2(cfg.sync_start_mode)) {
fail("DI_SYN2 cannot be used simultaneously for start and stop");
}
if (cfg.mode == X502_LCH_MODE_DIFF) {
if ((cfg.ch1 >= X502_ADC_DIFF_CH_CNT) || (cfg.ch2 >= X502_ADC_DIFF_CH_CNT)) {
fail("For differential mode E-502 channels must be in range 0..15");
}
} else {
if ((cfg.ch1 >= X502_ADC_COMM_CH_CNT) || (cfg.ch2 >= X502_ADC_COMM_CH_CNT)) {
fail("For common-ground mode E-502 channels must be in range 0..31");
}
}
return cfg;
}
template <typename Fn>
Fn load_symbol(HMODULE module, const char* name) {
const auto addr = GetProcAddress(module, name);
if (addr == nullptr) {
fail(std::string("GetProcAddress failed for symbol: ") + name);
}
return reinterpret_cast<Fn>(addr);
}
struct Api {
HMODULE x502_module = nullptr;
HMODULE e502_module = nullptr;
decltype(&X502_Create) Create = nullptr;
decltype(&X502_Free) Free = nullptr;
decltype(&X502_Close) Close = nullptr;
decltype(&X502_GetErrorString) GetErrorString = nullptr;
decltype(&X502_GetDevInfo2) GetDevInfo2 = nullptr;
decltype(&X502_SetMode) SetMode = nullptr;
decltype(&X502_StreamsStop) StreamsStop = nullptr;
decltype(&X502_StreamsDisable) StreamsDisable = nullptr;
decltype(&X502_SetSyncMode) SetSyncMode = nullptr;
decltype(&X502_SetSyncStartMode) SetSyncStartMode = nullptr;
decltype(&X502_SetLChannelCount) SetLChannelCount = nullptr;
decltype(&X502_SetLChannel) SetLChannel = nullptr;
decltype(&X502_SetAdcFreqDivider) SetAdcFreqDivider = nullptr;
decltype(&X502_SetAdcInterframeDelay) SetAdcInterframeDelay = nullptr;
decltype(&X502_SetStreamBufSize) SetStreamBufSize = nullptr;
decltype(&X502_SetStreamStep) SetStreamStep = nullptr;
decltype(&X502_SetDigInPullup) SetDigInPullup = nullptr;
decltype(&X502_SetExtRefFreqValue) SetExtRefFreqValue = nullptr;
decltype(&X502_Configure) Configure = nullptr;
decltype(&X502_StreamsEnable) StreamsEnable = nullptr;
decltype(&X502_StreamsStart) StreamsStart = nullptr;
decltype(&X502_AsyncInDig) AsyncInDig = nullptr;
decltype(&X502_Recv) Recv = nullptr;
decltype(&X502_ProcessAdcData) ProcessAdcData = nullptr;
decltype(&E502_OpenUsb) OpenUsb = nullptr;
decltype(&E502_OpenByIpAddr) OpenByIpAddr = nullptr;
Api() {
x502_module = LoadLibraryA("x502api.dll");
if (x502_module == nullptr) {
fail("Cannot load x502api.dll");
}
e502_module = LoadLibraryA("e502api.dll");
if (e502_module == nullptr) {
fail("Cannot load e502api.dll");
}
Create = load_symbol<decltype(Create)>(x502_module, "X502_Create");
Free = load_symbol<decltype(Free)>(x502_module, "X502_Free");
Close = load_symbol<decltype(Close)>(x502_module, "X502_Close");
GetErrorString = load_symbol<decltype(GetErrorString)>(x502_module, "X502_GetErrorString");
GetDevInfo2 = load_symbol<decltype(GetDevInfo2)>(x502_module, "X502_GetDevInfo2");
SetMode = load_symbol<decltype(SetMode)>(x502_module, "X502_SetMode");
StreamsStop = load_symbol<decltype(StreamsStop)>(x502_module, "X502_StreamsStop");
StreamsDisable = load_symbol<decltype(StreamsDisable)>(x502_module, "X502_StreamsDisable");
SetSyncMode = load_symbol<decltype(SetSyncMode)>(x502_module, "X502_SetSyncMode");
SetSyncStartMode = load_symbol<decltype(SetSyncStartMode)>(x502_module, "X502_SetSyncStartMode");
SetLChannelCount = load_symbol<decltype(SetLChannelCount)>(x502_module, "X502_SetLChannelCount");
SetLChannel = load_symbol<decltype(SetLChannel)>(x502_module, "X502_SetLChannel");
SetAdcFreqDivider = load_symbol<decltype(SetAdcFreqDivider)>(x502_module, "X502_SetAdcFreqDivider");
SetAdcInterframeDelay = load_symbol<decltype(SetAdcInterframeDelay)>(x502_module, "X502_SetAdcInterframeDelay");
SetStreamBufSize = load_symbol<decltype(SetStreamBufSize)>(x502_module, "X502_SetStreamBufSize");
SetStreamStep = load_symbol<decltype(SetStreamStep)>(x502_module, "X502_SetStreamStep");
SetDigInPullup = load_symbol<decltype(SetDigInPullup)>(x502_module, "X502_SetDigInPullup");
SetExtRefFreqValue = load_symbol<decltype(SetExtRefFreqValue)>(x502_module, "X502_SetExtRefFreqValue");
Configure = load_symbol<decltype(Configure)>(x502_module, "X502_Configure");
StreamsEnable = load_symbol<decltype(StreamsEnable)>(x502_module, "X502_StreamsEnable");
StreamsStart = load_symbol<decltype(StreamsStart)>(x502_module, "X502_StreamsStart");
AsyncInDig = load_symbol<decltype(AsyncInDig)>(x502_module, "X502_AsyncInDig");
Recv = load_symbol<decltype(Recv)>(x502_module, "X502_Recv");
ProcessAdcData = load_symbol<decltype(ProcessAdcData)>(x502_module, "X502_ProcessAdcData");
OpenUsb = load_symbol<decltype(OpenUsb)>(e502_module, "E502_OpenUsb");
OpenByIpAddr = load_symbol<decltype(OpenByIpAddr)>(e502_module, "E502_OpenByIpAddr");
}
~Api() {
if (e502_module != nullptr) {
FreeLibrary(e502_module);
}
if (x502_module != nullptr) {
FreeLibrary(x502_module);
}
}
};
std::string x502_error(const Api& api, int32_t err) {
const char* text = api.GetErrorString ? api.GetErrorString(err) : nullptr;
std::ostringstream out;
out << "err=" << err;
if ((text != nullptr) && (*text != '\0')) {
out << " (" << text << ")";
}
return out.str();
}
void expect_ok(const Api& api, int32_t err, const std::string& what) {
if (err != X502_ERR_OK) {
fail(what + ": " + x502_error(api, err));
}
}
constexpr uint32_t kE502DiSyn2Mask =
(static_cast<uint32_t>(1U) << 13U) | (static_cast<uint32_t>(1U) << 17U);
bool read_di_syn2_level(const Api& api, t_x502_hnd hnd) {
uint32_t din = 0;
expect_ok(api, api.AsyncInDig(hnd, &din), "Read digital inputs");
return (din & kE502DiSyn2Mask) != 0;
}
struct DeviceHandle {
const Api& api;
t_x502_hnd hnd = nullptr;
bool opened = false;
bool streams_started = false;
explicit DeviceHandle(const Api& api_ref) : api(api_ref), hnd(api.Create()) {
if (hnd == nullptr) {
fail("X502_Create failed");
}
}
~DeviceHandle() {
if (hnd != nullptr) {
if (streams_started) {
api.StreamsStop(hnd);
}
if (opened) {
api.Close(hnd);
}
api.Free(hnd);
}
}
};
void print_device_info(const t_x502_info& info) {
std::cout << "Device: " << info.name << "\n"
<< "Serial: " << info.serial << "\n"
<< "FPGA version: " << static_cast<unsigned>(info.fpga_ver >> 8) << "."
<< static_cast<unsigned>(info.fpga_ver & 0xFF) << "\n"
<< "PLDA version: " << static_cast<unsigned>(info.plda_ver) << "\n"
<< "Board revision: " << static_cast<unsigned>(info.board_rev) << "\n"
<< "MCU firmware: " << info.mcu_firmware_ver << "\n";
}
struct PlotPoint {
std::size_t sample_index = 0;
double value = 0.0;
};
std::vector<PlotPoint> build_min_max_trace(const std::vector<double>& data, std::size_t max_columns) {
std::vector<PlotPoint> result;
if (data.empty()) {
return result;
}
const std::size_t bucket_size = std::max<std::size_t>(1, (data.size() + max_columns - 1) / max_columns);
result.reserve(max_columns * 2);
for (std::size_t begin = 0; begin < data.size(); begin += bucket_size) {
const std::size_t end = std::min(begin + bucket_size, data.size());
std::size_t min_index = begin;
std::size_t max_index = begin;
for (std::size_t i = begin + 1; i < end; ++i) {
if (data[i] < data[min_index]) {
min_index = i;
}
if (data[i] > data[max_index]) {
max_index = i;
}
}
if (min_index <= max_index) {
result.push_back({min_index, data[min_index]});
if (max_index != min_index) {
result.push_back({max_index, data[max_index]});
}
} else {
result.push_back({max_index, data[max_index]});
result.push_back({min_index, data[min_index]});
}
}
if (result.back().sample_index != (data.size() - 1)) {
result.push_back({data.size() - 1, data.back()});
}
return result;
}
std::string polyline_points(const std::vector<PlotPoint>& trace,
double max_time_s,
double y_min,
double y_max,
double left,
double top,
double width,
double height) {
std::ostringstream out;
out << std::fixed << std::setprecision(3);
const double y_span = std::max(1e-12, y_max - y_min);
const std::size_t max_index = trace.empty() ? 1 : trace.back().sample_index;
const double time_scale = (max_time_s > 0.0) ? max_time_s : 1.0;
for (const auto& point : trace) {
const double time_s = (max_index == 0)
? 0.0
: (static_cast<double>(point.sample_index) / static_cast<double>(max_index)) * time_scale;
const double x = left + (time_s / time_scale) * width;
const double y = top + height - ((point.value - y_min) / y_span) * height;
out << x << "," << y << " ";
}
return out.str();
}
void write_csv(const std::string& path,
const std::vector<double>& ch1,
const std::vector<double>& ch2,
double frame_freq_hz) {
std::ofstream file(path, std::ios::binary);
if (!file) {
fail("Cannot open CSV for writing: " + path);
}
file << "frame_index,time_s,ch1_v,ch2_v\n";
file << std::fixed << std::setprecision(9);
const std::size_t frames = std::min(ch1.size(), ch2.size());
for (std::size_t i = 0; i < frames; ++i) {
const double time_s = static_cast<double>(i) / frame_freq_hz;
file << i << "," << time_s << "," << ch1[i] << "," << ch2[i] << "\n";
}
}
void write_svg(const std::string& path,
const std::vector<double>& ch1,
const std::vector<double>& ch2,
double frame_freq_hz,
double nominal_range_v) {
std::ofstream file(path, std::ios::binary);
if (!file) {
fail("Cannot open SVG for writing: " + path);
}
const std::size_t frames = std::min(ch1.size(), ch2.size());
const double total_time_s = (frames > 1) ? (static_cast<double>(frames - 1) / frame_freq_hz) : 0.0;
double min_y = std::numeric_limits<double>::infinity();
double max_y = -std::numeric_limits<double>::infinity();
for (double v : ch1) {
min_y = std::min(min_y, v);
max_y = std::max(max_y, v);
}
for (double v : ch2) {
min_y = std::min(min_y, v);
max_y = std::max(max_y, v);
}
if (!std::isfinite(min_y) || !std::isfinite(max_y) || (min_y == max_y)) {
min_y = -nominal_range_v;
max_y = nominal_range_v;
} else {
const double pad = std::max(0.1, (max_y - min_y) * 0.08);
min_y -= pad;
max_y += pad;
}
const auto trace1 = build_min_max_trace(ch1, 1800);
const auto trace2 = build_min_max_trace(ch2, 1800);
const double width = 1400.0;
const double height = 800.0;
const double left = 90.0;
const double right = 40.0;
const double top = 40.0;
const double bottom = 80.0;
const double plot_w = width - left - right;
const double plot_h = height - top - bottom;
const double zero_y = top + plot_h - ((0.0 - min_y) / std::max(1e-12, max_y - min_y)) * plot_h;
file << "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" << width
<< "\" height=\"" << height << "\" viewBox=\"0 0 " << width << " " << height << "\">\n";
file << " <rect width=\"100%\" height=\"100%\" fill=\"#ffffff\"/>\n";
file << " <rect x=\"" << left << "\" y=\"" << top << "\" width=\"" << plot_w
<< "\" height=\"" << plot_h << "\" fill=\"#fbfcfe\" stroke=\"#ccd4dd\"/>\n";
for (int i = 0; i <= 10; ++i) {
const double x = left + (plot_w * i / 10.0);
const double y = top + (plot_h * i / 10.0);
file << " <line x1=\"" << x << "\" y1=\"" << top << "\" x2=\"" << x << "\" y2=\"" << (top + plot_h)
<< "\" stroke=\"#edf1f5\" stroke-width=\"1\"/>\n";
file << " <line x1=\"" << left << "\" y1=\"" << y << "\" x2=\"" << (left + plot_w) << "\" y2=\"" << y
<< "\" stroke=\"#edf1f5\" stroke-width=\"1\"/>\n";
}
if ((0.0 >= min_y) && (0.0 <= max_y)) {
file << " <line x1=\"" << left << "\" y1=\"" << zero_y << "\" x2=\"" << (left + plot_w)
<< "\" y2=\"" << zero_y << "\" stroke=\"#8fa1b3\" stroke-width=\"1.2\"/>\n";
}
file << " <polyline fill=\"none\" stroke=\"#005bbb\" stroke-width=\"1.2\" points=\""
<< polyline_points(trace1, total_time_s, min_y, max_y, left, top, plot_w, plot_h) << "\"/>\n";
file << " <polyline fill=\"none\" stroke=\"#d62828\" stroke-width=\"1.2\" points=\""
<< polyline_points(trace2, total_time_s, min_y, max_y, left, top, plot_w, plot_h) << "\"/>\n";
file << " <text x=\"" << left << "\" y=\"24\" font-size=\"22\" font-family=\"Segoe UI, Arial, sans-serif\""
<< " fill=\"#203040\">E-502 capture: CH1 and CH2</text>\n";
file << " <text x=\"" << left << "\" y=\"" << (height - 22)
<< "\" font-size=\"16\" font-family=\"Segoe UI, Arial, sans-serif\" fill=\"#425466\">time, s</text>\n";
file << " <text x=\"18\" y=\"" << (top + 16)
<< "\" font-size=\"16\" font-family=\"Segoe UI, Arial, sans-serif\" fill=\"#425466\">V</text>\n";
file << std::fixed << std::setprecision(6);
for (int i = 0; i <= 10; ++i) {
const double x = left + (plot_w * i / 10.0);
const double t = total_time_s * i / 10.0;
file << " <text x=\"" << x << "\" y=\"" << (top + plot_h + 24)
<< "\" text-anchor=\"middle\" font-size=\"12\" font-family=\"Segoe UI, Arial, sans-serif\""
<< " fill=\"#607080\">" << t << "</text>\n";
const double y = top + plot_h - (plot_h * i / 10.0);
const double v = min_y + (max_y - min_y) * i / 10.0;
file << " <text x=\"" << (left - 10) << "\" y=\"" << (y + 4)
<< "\" text-anchor=\"end\" font-size=\"12\" font-family=\"Segoe UI, Arial, sans-serif\""
<< " fill=\"#607080\">" << v << "</text>\n";
}
const double legend_y = height - 48.0;
file << " <line x1=\"" << (width - 270) << "\" y1=\"" << legend_y
<< "\" x2=\"" << (width - 230) << "\" y2=\"" << legend_y
<< "\" stroke=\"#005bbb\" stroke-width=\"3\"/>\n";
file << " <text x=\"" << (width - 220) << "\" y=\"" << (legend_y + 4)
<< "\" font-size=\"14\" font-family=\"Segoe UI, Arial, sans-serif\" fill=\"#203040\">CH1</text>\n";
file << " <line x1=\"" << (width - 160) << "\" y1=\"" << legend_y
<< "\" x2=\"" << (width - 120) << "\" y2=\"" << legend_y
<< "\" stroke=\"#d62828\" stroke-width=\"3\"/>\n";
file << " <text x=\"" << (width - 110) << "\" y=\"" << (legend_y + 4)
<< "\" font-size=\"14\" font-family=\"Segoe UI, Arial, sans-serif\" fill=\"#203040\">CH2</text>\n";
file << "</svg>\n";
}
int run(const Config& cfg) {
Api api;
DeviceHandle device(api);
int32_t err = X502_ERR_OK;
if (cfg.ip_addr.has_value()) {
err = api.OpenByIpAddr(device.hnd, *cfg.ip_addr, 0, 5000);
} else {
err = api.OpenUsb(device.hnd, cfg.serial.empty() ? nullptr : cfg.serial.c_str());
}
expect_ok(api, err, "Open device");
device.opened = true;
t_x502_info info{};
err = api.GetDevInfo2(device.hnd, &info, sizeof(info));
expect_ok(api, err, "Get device info");
print_device_info(info);
expect_ok(api, api.SetMode(device.hnd, X502_MODE_FPGA), "Set FPGA mode");
api.StreamsStop(device.hnd);
api.StreamsDisable(device.hnd, X502_STREAM_ALL_IN | X502_STREAM_ALL_OUT);
expect_ok(api, api.SetSyncMode(device.hnd, cfg.sync_mode), "Set sync mode");
expect_ok(api, api.SetSyncStartMode(device.hnd, cfg.sync_start_mode), "Set sync start mode");
if (cfg.sync_mode != X502_SYNC_INTERNAL) {
const int32_t ext_ref_err = api.SetExtRefFreqValue(device.hnd, cfg.sample_clock_hz);
if (ext_ref_err != X502_ERR_OK) {
if (cfg.sample_clock_hz <= 1500000.0) {
expect_ok(api, ext_ref_err, "Set external reference frequency");
} else {
std::cerr << "Warning: X502_SetExtRefFreqValue(" << cfg.sample_clock_hz
<< ") failed, continuing with manual divider configuration: "
<< x502_error(api, ext_ref_err) << "\n";
}
}
}
expect_ok(api, api.SetLChannelCount(device.hnd, 2), "Set logical channel count");
expect_ok(api, api.SetLChannel(device.hnd, 0, cfg.ch1, cfg.mode, cfg.range, 1), "Set logical channel 0");
expect_ok(api, api.SetLChannel(device.hnd, 1, cfg.ch2, cfg.mode, cfg.range, 1), "Set logical channel 1");
expect_ok(api, api.SetAdcFreqDivider(device.hnd, 1), "Set ADC frequency divider");
expect_ok(api, api.SetAdcInterframeDelay(device.hnd, 0), "Set ADC interframe delay");
expect_ok(api, api.SetStreamBufSize(device.hnd, X502_STREAM_CH_IN, cfg.input_buffer_words), "Set input buffer size");
expect_ok(api, api.SetStreamStep(device.hnd, X502_STREAM_CH_IN, cfg.input_step_words), "Set input stream step");
uint32_t pullups = 0;
if (cfg.pullup_syn1) {
pullups |= X502_PULLUPS_DI_SYN1;
}
if (cfg.pullup_syn2) {
pullups |= X502_PULLUPS_DI_SYN2;
}
if (cfg.pulldown_conv_in) {
pullups |= X502_PULLDOWN_CONV_IN;
}
if (cfg.pulldown_start_in) {
pullups |= X502_PULLDOWN_START_IN;
}
expect_ok(api, api.SetDigInPullup(device.hnd, pullups), "Set digital input pullups/pulldowns");
expect_ok(api, api.Configure(device.hnd, 0), "Configure device");
expect_ok(api, api.StreamsEnable(device.hnd, X502_STREAM_ADC), "Enable ADC stream");
const double frame_freq_hz = cfg.sample_clock_hz / 2.0;
const std::size_t target_frames = std::max<std::size_t>(
1, static_cast<std::size_t>(std::llround((cfg.duration_ms / 1000.0) * frame_freq_hz)));
std::cout << "Capture settings:\n"
<< " clock source: " << sync_mode_to_string(cfg.sync_mode, false) << "\n"
<< " start source: " << sync_mode_to_string(cfg.sync_start_mode, true) << "\n"
<< " stop source: " << stop_mode_to_string(cfg.stop_mode) << "\n"
<< " sample clock: " << cfg.sample_clock_hz << " Hz\n"
<< " per-channel frame rate: " << frame_freq_hz << " Hz\n"
<< " duration: " << cfg.duration_ms << " ms\n"
<< " channel 1: " << phy_channel_name(cfg.mode, cfg.ch1) << "\n"
<< " channel 2: " << phy_channel_name(cfg.mode, cfg.ch2) << "\n"
<< " ADC range: +/-" << range_to_volts(cfg.range) << " V\n"
<< " target frames per channel: " << target_frames << "\n";
expect_ok(api, api.StreamsStart(device.hnd), "Start streams");
device.streams_started = true;
std::vector<uint32_t> raw(cfg.recv_block_words);
std::vector<double> processed(cfg.recv_block_words);
std::array<std::vector<double>, 2> channels;
channels[0].reserve(target_frames);
channels[1].reserve(target_frames);
bool capture_started = false;
bool stop_requested = false;
bool stop_prev_initialized = false;
bool stop_prev_level = false;
bool stopped_by_external_signal = false;
uint32_t next_lch = 0;
const ULONGLONG start_wait_deadline = GetTickCount64() + cfg.start_wait_ms;
while (!stop_requested &&
((channels[0].size() < target_frames) || (channels[1].size() < target_frames))) {
const int32_t recvd = api.Recv(device.hnd, raw.data(), cfg.recv_block_words, cfg.recv_timeout_ms);
if (recvd < 0) {
fail("X502_Recv failed: " + x502_error(api, recvd));
}
if (recvd == 0) {
if (!capture_started && (GetTickCount64() >= start_wait_deadline)) {
std::ostringstream message;
message << "Timeout before first ADC data. start="
<< sync_mode_to_string(cfg.sync_start_mode, true)
<< ", clock=" << sync_mode_to_string(cfg.sync_mode, false) << ". ";
if (cfg.sync_start_mode == X502_SYNC_EXTERNAL_MASTER) {
message << "With start:start_in the module waits for START_IN after StreamsStart(); "
"until that condition occurs the external clock is ignored. ";
} else if (cfg.sync_start_mode == X502_SYNC_INTERNAL) {
message << "Start is immediate, so this usually means there is no valid external clock on the selected clock line. ";
} else {
message << "This usually means the selected start condition did not occur after StreamsStart(), "
"or no valid external clock arrived afterwards. ";
}
message << "For a quick clock-only check, try start:immediate. "
"If you use a separate start pulse, it must arrive after the program starts waiting. "
"You can also increase start_wait_ms.";
fail(message.str());
}
continue;
}
uint32_t adc_count = static_cast<uint32_t>(recvd);
expect_ok(api,
api.ProcessAdcData(device.hnd, raw.data(), processed.data(), &adc_count, X502_PROC_FLAGS_VOLT),
"Process ADC data");
if (adc_count == 0) {
continue;
}
capture_started = true;
for (uint32_t i = 0; i < adc_count; ++i) {
const uint32_t lch = next_lch;
next_lch = (next_lch + 1U) % 2U;
if (channels[lch].size() < target_frames) {
channels[lch].push_back(processed[i]);
}
if ((channels[0].size() >= target_frames) && (channels[1].size() >= target_frames)) {
break;
}
}
if ((cfg.stop_mode != StopMode::TargetFrames) && capture_started) {
const bool stop_level = read_di_syn2_level(api, device.hnd);
if (!stop_prev_initialized) {
stop_prev_level = stop_level;
stop_prev_initialized = true;
} else {
const bool is_edge =
((cfg.stop_mode == StopMode::DiSyn2Rise) && !stop_prev_level && stop_level) ||
((cfg.stop_mode == StopMode::DiSyn2Fall) && stop_prev_level && !stop_level);
if (is_edge) {
stop_requested = true;
stopped_by_external_signal = true;
}
stop_prev_level = stop_level;
}
}
}
expect_ok(api, api.StreamsStop(device.hnd), "Stop streams");
device.streams_started = false;
const std::size_t frames = std::min(channels[0].size(), channels[1].size());
channels[0].resize(frames);
channels[1].resize(frames);
write_csv(cfg.csv_path, channels[0], channels[1], frame_freq_hz);
write_svg(cfg.svg_path, channels[0], channels[1], frame_freq_hz, range_to_volts(cfg.range));
std::cout << "Captured " << frames << " frames per channel\n"
<< "Stop reason: "
<< (stopped_by_external_signal ? "DI_SYN2 edge" : "target frame count") << "\n"
<< "CSV: " << cfg.csv_path << "\n"
<< "SVG: " << cfg.svg_path << "\n";
return 0;
}
} // namespace
int main(int argc, char** argv) {
try {
const Config cfg = parse_args(argc, argv);
return run(cfg);
} catch (const std::exception& ex) {
std::cerr << "Error: " << ex.what() << "\n";
return 1;
}
}
Reference in New Issue View Git Blame Copy Permalink