awe/radar_system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added GPR

Browse Source
This commit is contained in:
Ayzen
2026-03-19 19:29:08 +03:00
parent bdefe3f581
commit 9581730e41
39 changed files with 3830 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files
data_acq_and_processing/processing/data_processor/include/data_processor.hpp
+3
View File
@@ -2,6 +2,7 @@
#include <atomic>
#include <memory>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
@@ -29,11 +30,13 @@ class DataProcessor {
private:
[[nodiscard]] auto process_collection(
const ipc::PreprocessedCollection& preprocessed,
std::span<const ipc::PreprocessedCollection> previous_collections,
ProcessorInterface& processor,
const ProcessingLiveConfig& live_config
) -> ipc::ResultCollection;
[[nodiscard]] auto resolve_processor(const ProcessingLiveConfig& live_config) -> ProcessorInterface&;
[[nodiscard]] auto should_replay_entire_history(const ProcessingLiveConfig& live_config) const -> bool;
const config::RunConfig& config_;
ipc::ShmRing& preprocessed_ring_;
data_acq_and_processing/processing/data_processor/include/processing_live_config.hpp
+13
View File
@@ -4,6 +4,7 @@
#include <cstdint>
#include <filesystem>
#include <string>
#include <vector>
namespace radar::processing {
@@ -17,12 +18,24 @@ struct ProcessingLiveConfig {
std::string processor_mode = "pass_through";
float gain_db = 0.0F;
float phase_deg = 0.0F;
bool pass_through_fixed_y_enabled = false;
float pass_through_y_min_db = -100.0F;
float pass_through_y_max_db = 0.0F;
std::string bscan_axis = "abs";
float bscan_cut_m = 0.824F;
float bscan_max_depth_m = 1.0F;
float bscan_gain = 1.0F;
float bscan_start_freq_mhz = 100.0F;
float bscan_stop_freq_mhz = 8800.0F;
std::vector<std::uint32_t> gpr_input_positions{};
std::vector<std::uint32_t> gpr_output_positions{};
float gpr_min_depth_m = 2.0F;
float gpr_max_depth_m = 14.0F;
float gpr_comp_power = 0.2F;
float gpr_start_freq_mhz = 3000.0F;
float gpr_stop_freq_mhz = 6000.0F;
bool gpr_background_subtract_enabled = true;
std::uint32_t gpr_background_mean_count = 10U;
std::uint64_t history_command_seq = 0;
HistoryCommand history_command = HistoryCommand::None;
};
data_acq_and_processing/processing/data_processor/src/data_processor.cpp
+36 -24
View File
@@ -3,12 +3,13 @@
#include <algorithm>
#include <chrono>
#include <cstdint>
#include <deque>
#include <span>
#include <stdexcept>
#include <thread>
#include <utility>
#include "bscan_processor.hpp"
#include "gpr_processor.hpp"
#include "passthrough_processor.hpp"
namespace radar::processing {
@@ -54,7 +55,7 @@ DataProcessor::DataProcessor(
void DataProcessor::run(const std::atomic<bool>& stop_requested) {
std::vector<std::uint8_t> bytes{};
std::deque<ipc::PreprocessedCollection> preprocessed_history{};
std::vector<ipc::PreprocessedCollection> preprocessed_history{};
const std::size_t history_limit = replay_history_limit(config_);
std::uint64_t last_replayed_revision = live_config_loader_.revision();
std::uint64_t last_applied_history_command_seq = 0;
@@ -76,13 +77,23 @@ void DataProcessor::run(const std::atomic<bool>& stop_requested) {
last_applied_history_command_seq = live_config.history_command_seq;
}
if (live_config.processor_mode == "bscan") {
for (const auto& cached : preprocessed_history) {
const auto replay_result = process_collection(cached, processor, live_config);
if (should_replay_entire_history(live_config)) {
for (std::size_t index = 0; index < preprocessed_history.size(); ++index) {
const auto replay_result = process_collection(
preprocessed_history[index],
std::span<const ipc::PreprocessedCollection>(preprocessed_history.data(), index),
processor,
live_config
);
publish_result_collection(replay_result, results_ring_);
}
} else if (!preprocessed_history.empty()) {
const auto replay_result = process_collection(preprocessed_history.back(), processor, live_config);
const auto replay_result = process_collection(
preprocessed_history.back(),
std::span<const ipc::PreprocessedCollection>(preprocessed_history.data(), preprocessed_history.size() - 1U),
processor,
live_config
);
publish_result_collection(replay_result, results_ring_);
}
last_replayed_revision = live_revision;
@@ -92,10 +103,15 @@ void DataProcessor::run(const std::atomic<bool>& stop_requested) {
auto preprocessed = ipc::deserialize_preprocessed_collection(bytes);
preprocessed_history.push_back(std::move(preprocessed));
while (preprocessed_history.size() > history_limit) {
preprocessed_history.pop_front();
preprocessed_history.erase(preprocessed_history.begin());
}
const auto result_collection = process_collection(preprocessed_history.back(), processor, live_config);
const auto result_collection = process_collection(
preprocessed_history.back(),
std::span<const ipc::PreprocessedCollection>(preprocessed_history.data(), preprocessed_history.size() - 1U),
processor,
live_config
);
publish_result_collection(result_collection, results_ring_);
continue;
}
@@ -106,25 +122,11 @@ void DataProcessor::run(const std::atomic<bool>& stop_requested) {
auto DataProcessor::process_collection(
const ipc::PreprocessedCollection& preprocessed,
std::span<const ipc::PreprocessedCollection> previous_collections,
ProcessorInterface& processor,
const ProcessingLiveConfig& live_config
) -> ipc::ResultCollection {
ipc::ResultCollection results{};
results.collection_id = preprocessed.collection_id;
// Keep source monotonic timestamp stable across live-config replays.
results.monotonic_ns = preprocessed.monotonic_ns;
results.blocks.reserve(preprocessed.traces.size());
for (const auto& trace : preprocessed.traces) {
ipc::ResultBlock block{};
block.combo = trace.combo;
block.payloads.reserve(1U);
block.payloads.push_back(processor.process(trace, live_config));
results.blocks.push_back(std::move(block));
}
return results;
return processor.process_collection(config_, preprocessed, previous_collections, live_config);
}
auto DataProcessor::resolve_processor(const ProcessingLiveConfig& live_config) -> ProcessorInterface& {
@@ -140,6 +142,12 @@ auto DataProcessor::resolve_processor(const ProcessingLiveConfig& live_config) -
return *(processors_.begin()->second);
}
auto DataProcessor::should_replay_entire_history(const ProcessingLiveConfig& live_config) const -> bool {
const std::string requested_mode =
live_config.processor_mode.empty() ? default_processor_mode_ : live_config.processor_mode;
return requested_mode == "bscan";
}
auto create_default_processors() -> ProcessorRegistry {
ProcessorRegistry processors{};
{
@@ -150,6 +158,10 @@ auto create_default_processors() -> ProcessorRegistry {
auto processor = std::make_unique<BScanProcessor>();
processors.emplace(processor->name(), std::move(processor));
}
{
auto processor = std::make_unique<GprProcessor>();
processors.emplace(processor->name(), std::move(processor));
}
return processors;
}
data_acq_and_processing/processing/data_processor/src/processing_live_config.cpp
+84
View File
@@ -45,6 +45,27 @@ using Json = nlohmann::json;
return static_cast<std::uint64_t>(rounded);
}
[[nodiscard]] auto parse_u32_number(const Json& value, const std::string& field_name) -> std::uint32_t {
const auto parsed = parse_u64_number(value, field_name);
if (parsed > static_cast<std::uint64_t>(std::numeric_limits<std::uint32_t>::max())) {
throw std::runtime_error(field_name + " is out of uint32 range");
}
return static_cast<std::uint32_t>(parsed);
}
[[nodiscard]] auto parse_u32_array(const Json& value, const std::string& field_name) -> std::vector<std::uint32_t> {
if (!value.is_array()) {
throw std::runtime_error(field_name + " must be array");
}
std::vector<std::uint32_t> result{};
result.reserve(value.size());
for (std::size_t index = 0; index < value.size(); ++index) {
result.push_back(parse_u32_number(value[index], field_name + "[" + std::to_string(index) + "]"));
}
return result;
}
[[nodiscard]] auto parse_live_config(const std::string& json_text, const std::string& path) -> ProcessingLiveConfig {
if (json_text.empty()) {
throw std::runtime_error("Processing live config is empty: " + path);
@@ -80,6 +101,24 @@ using Json = nlohmann::json;
}
config.phase_deg = static_cast<float>(found->get<double>());
}
if (const auto found = root.find("pass_through_fixed_y_enabled"); found != root.end()) {
if (!found->is_boolean()) {
throw std::runtime_error("processing.pass_through_fixed_y_enabled must be bool");
}
config.pass_through_fixed_y_enabled = found->get<bool>();
}
if (const auto found = root.find("pass_through_y_min_db"); found != root.end()) {
if (!found->is_number()) {
throw std::runtime_error("processing.pass_through_y_min_db must be number");
}
config.pass_through_y_min_db = static_cast<float>(found->get<double>());
}
if (const auto found = root.find("pass_through_y_max_db"); found != root.end()) {
if (!found->is_number()) {
throw std::runtime_error("processing.pass_through_y_max_db must be number");
}
config.pass_through_y_max_db = static_cast<float>(found->get<double>());
}
if (const auto found = root.find("bscan_axis"); found != root.end()) {
if (!found->is_string()) {
throw std::runtime_error("processing.bscan_axis must be string");
@@ -116,6 +155,51 @@ using Json = nlohmann::json;
}
config.bscan_stop_freq_mhz = static_cast<float>(found->get<double>());
}
if (const auto found = root.find("gpr_input_positions"); found != root.end()) {
config.gpr_input_positions = parse_u32_array(*found, "processing.gpr_input_positions");
}
if (const auto found = root.find("gpr_output_positions"); found != root.end()) {
config.gpr_output_positions = parse_u32_array(*found, "processing.gpr_output_positions");
}
if (const auto found = root.find("gpr_min_depth_m"); found != root.end()) {
if (!found->is_number()) {
throw std::runtime_error("processing.gpr_min_depth_m must be number");
}
config.gpr_min_depth_m = static_cast<float>(found->get<double>());
}
if (const auto found = root.find("gpr_max_depth_m"); found != root.end()) {
if (!found->is_number()) {
throw std::runtime_error("processing.gpr_max_depth_m must be number");
}
config.gpr_max_depth_m = static_cast<float>(found->get<double>());
}
if (const auto found = root.find("gpr_comp_power"); found != root.end()) {
if (!found->is_number()) {
throw std::runtime_error("processing.gpr_comp_power must be number");
}
config.gpr_comp_power = static_cast<float>(found->get<double>());
}
if (const auto found = root.find("gpr_start_freq_mhz"); found != root.end()) {
if (!found->is_number()) {
throw std::runtime_error("processing.gpr_start_freq_mhz must be number");
}
config.gpr_start_freq_mhz = static_cast<float>(found->get<double>());
}
if (const auto found = root.find("gpr_stop_freq_mhz"); found != root.end()) {
if (!found->is_number()) {
throw std::runtime_error("processing.gpr_stop_freq_mhz must be number");
}
config.gpr_stop_freq_mhz = static_cast<float>(found->get<double>());
}
if (const auto found = root.find("gpr_background_subtract_enabled"); found != root.end()) {
if (!found->is_boolean()) {
throw std::runtime_error("processing.gpr_background_subtract_enabled must be bool");
}
config.gpr_background_subtract_enabled = found->get<bool>();
}
if (const auto found = root.find("gpr_background_mean_count"); found != root.end()) {
config.gpr_background_mean_count = parse_u32_number(*found, "processing.gpr_background_mean_count");
}
if (const auto found = root.find("history_command_seq"); found != root.end()) {
config.history_command_seq = parse_u64_number(*found, "processing.history_command_seq");
}