From 66fc8eb9a4d5cda1b9455746d611769c2ba0e439 Mon Sep 17 00:00:00 2001 From: crosstyan Date: Wed, 17 Jun 2026 16:06:36 +0800 Subject: [PATCH] feat(track-core): add display test state --- include/app_track_model.hpp | 176 ++++++++++++++++++++++++----------- include/track_core/model.hpp | 2 +- src/esp/app_track_drawer.cpp | 4 +- src/esp/app_track_model.cpp | 4 +- src/python/bindings.cpp | 2 +- 5 files changed, 130 insertions(+), 58 deletions(-) diff --git a/include/app_track_model.hpp b/include/app_track_model.hpp index 1d83af8..48e3761 100644 --- a/include/app_track_model.hpp +++ b/include/app_track_model.hpp @@ -284,6 +284,8 @@ struct TrackSchemeMgrRead { using TrackState = track_app_TrackState; using TrackControllerMode = track_app_TrackControllerMode; +using TrackDisplayTestPattern = track_app_TrackDisplayTestPattern; +using TrackDisplayTestEffect = track_app_TrackDisplayTestEffect; using TrackPidStageKind = track_app_TrackPidStageKind; constexpr float PID_COMPAT_OUTPUT_SCALE_MAX_M_S = 10.0F; @@ -797,69 +799,139 @@ struct TrackPidStatus { } }; -struct TrackTestParameters { - using proto_type = track_app_TrackTestParameters; - static inline const pb_msgdesc_t *pb_fields = &track_app_TrackTestParameters_msg; +struct TrackDisplayTestParameters { + using proto_type = track_app_TrackDisplayTestParameters; + static inline const pb_msgdesc_t *pb_fields = &track_app_TrackDisplayTestParameters_msg; - /** properties */ - Color blink_color{Color::green()}; + TrackDisplayTestPattern pattern{ + track_app_TrackDisplayTestPattern_TRACK_DISPLAY_TEST_PATTERN_BLINK}; + TrackDisplayTestEffect effect{ + track_app_TrackDisplayTestEffect_TRACK_DISPLAY_TEST_EFFECT_SOLID}; + uint8_t palette_index{15}; + optional color{std::nullopt}; + uint16_t period_ms{500}; + bool has_target_range{false}; + uint16_t target_start{0}; + uint16_t target_end{0}; + bool wrap{false}; + uint16_t window_size{1}; + uint16_t step{1}; + bool preserve_others{false}; uint8_t blink_duty_cycle_percent{128}; - uint32_t blink_period_ms{1'000}; - uint32_t rainbow_move_speed_leds_per_sec{0}; - uint16_t segment_led_start{0}; - uint16_t segment_led_count{0}; - uint16_t highlight_last_n_leds{0}; - uint8_t blink_palette_index{0}; + uint16_t repeat_count{3}; + optional random_seed{std::nullopt}; - static TrackTestParameters from_proto(const proto_type &proto) { - TrackTestParameters params; - if (proto.has_blink_color) { - params.blink_color = Color::from_proto(proto.blink_color); + static TrackDisplayTestParameters from_proto(const proto_type &proto) { + TrackDisplayTestParameters params; + params.pattern = proto.pattern; + params.effect = proto.effect; + params.palette_index = proto.palette_index; + if (proto.has_color) { + params.color = Color::from_proto(proto.color); + } + params.period_ms = proto.period_ms; + params.has_target_range = proto.has_target_range; + params.target_start = proto.target_start; + params.target_end = proto.target_end; + params.wrap = proto.wrap; + params.window_size = proto.window_size; + params.step = proto.step; + params.preserve_others = proto.preserve_others; + params.blink_duty_cycle_percent = proto.blink_duty_cycle_percent; + params.repeat_count = proto.repeat_count; + if (proto.has_random_seed) { + params.random_seed = proto.random_seed; } - params.blink_duty_cycle_percent = proto.blink_duty_cycle_percent; - params.blink_period_ms = proto.blink_period_ms; - params.rainbow_move_speed_leds_per_sec = proto.rainbow_move_speed_leds_per_sec; - params.segment_led_start = proto.segment_led_start; - params.segment_led_count = proto.segment_led_count; - params.highlight_last_n_leds = proto.highlight_last_n_leds; - params.blink_palette_index = proto.blink_palette_index; return params; } [[nodiscard]] proto_type to_proto() const { proto_type proto{}; - proto.has_blink_color = true; - proto.blink_color = blink_color.to_proto(); - proto.blink_duty_cycle_percent = blink_duty_cycle_percent; - proto.blink_period_ms = blink_period_ms; - proto.rainbow_move_speed_leds_per_sec = rainbow_move_speed_leds_per_sec; - proto.segment_led_start = segment_led_start; - proto.segment_led_count = segment_led_count; - proto.highlight_last_n_leds = highlight_last_n_leds; - proto.blink_palette_index = blink_palette_index; + proto.pattern = pattern; + proto.effect = effect; + proto.palette_index = palette_index; + if (color.has_value()) { + proto.has_color = true; + proto.color = color->to_proto(); + } + proto.period_ms = period_ms; + proto.has_target_range = has_target_range; + proto.target_start = target_start; + proto.target_end = target_end; + proto.wrap = wrap; + proto.window_size = window_size; + proto.step = step; + proto.preserve_others = preserve_others; + proto.blink_duty_cycle_percent = blink_duty_cycle_percent; + proto.repeat_count = repeat_count; + if (random_seed.has_value()) { + proto.has_random_seed = true; + proto.random_seed = *random_seed; + } return proto; } + static const char *pattern_to_str(TrackDisplayTestPattern value) { + switch (value) { + case track_app_TrackDisplayTestPattern_TRACK_DISPLAY_TEST_PATTERN_LIGHT: + return "LIGHT"; + case track_app_TrackDisplayTestPattern_TRACK_DISPLAY_TEST_PATTERN_BLINK: + return "BLINK"; + case track_app_TrackDisplayTestPattern_TRACK_DISPLAY_TEST_PATTERN_SCAN: + return "SCAN"; + } + return "UNKNOWN"; + } + + static const char *effect_to_str(TrackDisplayTestEffect value) { + switch (value) { + case track_app_TrackDisplayTestEffect_TRACK_DISPLAY_TEST_EFFECT_SOLID: + return "SOLID"; + case track_app_TrackDisplayTestEffect_TRACK_DISPLAY_TEST_EFFECT_RAINBOW: + return "RAINBOW"; + case track_app_TrackDisplayTestEffect_TRACK_DISPLAY_TEST_EFFECT_RANDOM: + return "RANDOM"; + } + return "UNKNOWN"; + } + void log(const char *tag, esp_log_level_t level) const { + const auto color_text = color.has_value() ? color->string() : std::string{""}; ESP_LOG_LEVEL(level, tag, - "TrackTestParameters{" - ".blink_color=%s, " + "TrackDisplayTestParameters{" + ".pattern=%s, " + ".effect=%s, " + ".palette_index=%" PRIu8 ", " + ".color=%s, " + ".period_ms=%" PRIu16 ", " + ".has_target_range=%d, " + ".target_start=%" PRIu16 ", " + ".target_end=%" PRIu16 ", " + ".wrap=%d, " + ".window_size=%" PRIu16 ", " + ".step=%" PRIu16 ", " + ".preserve_others=%d, " ".blink_duty_cycle_percent=%" PRIu8 ", " - ".blink_period_ms=%" PRIu32 ", " - ".rainbow_move_speed_leds_per_sec=%" PRIu32 ", " - ".segment_led_start=%" PRIu16 ", " - ".segment_led_count=%" PRIu16 ", " - ".highlight_last_n_leds=%" PRIu16 ", " - ".blink_palette_index=%" PRIu8 "}", - blink_color.string().c_str(), + ".repeat_count=%" PRIu16 ", " + ".has_random_seed=%d, " + ".random_seed=%" PRIu32 "}", + pattern_to_str(pattern), + effect_to_str(effect), + palette_index, + color_text.c_str(), + period_ms, + has_target_range, + target_start, + target_end, + wrap, + window_size, + step, + preserve_others, blink_duty_cycle_percent, - blink_period_ms, - rainbow_move_speed_leds_per_sec, - segment_led_start, - segment_led_count, - highlight_last_n_leds, - blink_palette_index); + repeat_count, + random_seed.has_value(), + random_seed.value_or(0)); } }; @@ -868,16 +940,16 @@ struct TrackControlMsg { static inline const pb_msgdesc_t *pb_fields = &track_app_TrackControlMsg_msg; /** properties */ - std::variant state{unit{}}; + std::variant state{unit{}}; static TrackControlMsg from_proto(const proto_type &proto) { switch (proto.which_msg) { case track_app_TrackControlMsg_set_state_tag: return TrackControlMsg{.state = static_cast(proto.msg.set_state)}; - case track_app_TrackControlMsg_set_test_parameters_tag: - return TrackControlMsg{.state = TrackTestParameters::from_proto(proto.msg.set_test_parameters)}; case track_app_TrackControlMsg_set_mode_tag: return TrackControlMsg{.state = static_cast(proto.msg.set_mode)}; + case track_app_TrackControlMsg_set_display_test_parameters_tag: + return TrackControlMsg{.state = TrackDisplayTestParameters::from_proto(proto.msg.set_display_test_parameters)}; default: return TrackControlMsg{.state = unit{}}; } @@ -894,9 +966,9 @@ struct TrackControlMsg { proto.which_msg = track_app_TrackControlMsg_set_state_tag; proto.msg.set_state = static_cast(track_state); }, - [&](const TrackTestParameters &test_params) { - proto.which_msg = track_app_TrackControlMsg_set_test_parameters_tag; - proto.msg.set_test_parameters = test_params.to_proto(); + [&](const TrackDisplayTestParameters &test_params) { + proto.which_msg = track_app_TrackControlMsg_set_display_test_parameters_tag; + proto.msg.set_display_test_parameters = test_params.to_proto(); }, [&](TrackControllerMode mode) { proto.which_msg = track_app_TrackControlMsg_set_mode_tag; diff --git a/include/track_core/model.hpp b/include/track_core/model.hpp index fad4653..1162ea4 100644 --- a/include/track_core/model.hpp +++ b/include/track_core/model.hpp @@ -51,7 +51,7 @@ enum class TrackState : std::uint8_t { stop = 0, run = 1, test_rainbow = 2, - test_blink = 3, + test_display = 4, }; enum class TrackControllerMode : std::uint8_t { diff --git a/src/esp/app_track_drawer.cpp b/src/esp/app_track_drawer.cpp index 1dfd25d..1398fe4 100644 --- a/src/esp/app_track_drawer.cpp +++ b/src/esp/app_track_drawer.cpp @@ -55,8 +55,8 @@ track_core::TrackState to_core(app::track::TrackState state) { return track_core::TrackState::run; case track_app_TrackState_TEST_RAINBOW_CONTINUOUS: return track_core::TrackState::test_rainbow; - case track_app_TrackState_TEST_BLINK: - return track_core::TrackState::test_blink; + case track_app_TrackState_TEST_DISPLAY: + return track_core::TrackState::test_display; } return track_core::TrackState::stop; } diff --git a/src/esp/app_track_model.cpp b/src/esp/app_track_model.cpp index edb9726..f1db213 100644 --- a/src/esp/app_track_model.cpp +++ b/src/esp/app_track_model.cpp @@ -17,8 +17,8 @@ const char *to_str(TrackState status) { return "RUN"; case track_app_TrackState_TEST_RAINBOW_CONTINUOUS: return "TEST_RAINBOW_CONTINUOUS"; - case track_app_TrackState_TEST_BLINK: - return "TEST_BLINK"; + case track_app_TrackState_TEST_DISPLAY: + return "TEST_DISPLAY"; } return "UNKNOWN"; } diff --git a/src/python/bindings.cpp b/src/python/bindings.cpp index 8ee7ff0..7824de0 100644 --- a/src/python/bindings.cpp +++ b/src/python/bindings.cpp @@ -145,7 +145,7 @@ NB_MODULE(_core, m) { .value("stop", track_core::TrackState::stop) .value("run", track_core::TrackState::run) .value("test_rainbow", track_core::TrackState::test_rainbow) - .value("test_blink", track_core::TrackState::test_blink); + .value("test_display", track_core::TrackState::test_display); nb::class_(m, "Color") .def(nb::init<>())