feat(track-core): add display test state

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 {
+struct TrackDisplayTestParameters {
-	using proto_type                            = track_app_TrackTestParameters;
+	using proto_type                            = track_app_TrackDisplayTestParameters;
-	static inline const pb_msgdesc_t *pb_fields = &track_app_TrackTestParameters_msg;
+	static inline const pb_msgdesc_t *pb_fields = &track_app_TrackDisplayTestParameters_msg;
 
-	/** properties */
+	TrackDisplayTestPattern pattern{
-	Color blink_color{Color::green()};
+		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> 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};
+	uint16_t repeat_count{3};
-	uint32_t rainbow_move_speed_leds_per_sec{0};
+	optional<uint32_t> random_seed{std::nullopt};
-	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};
 
-	static TrackTestParameters from_proto(const proto_type &proto) {
+	static TrackDisplayTestParameters from_proto(const proto_type &proto) {
-		TrackTestParameters params;
+		TrackDisplayTestParameters params;
-		if (proto.has_blink_color) {
+		params.pattern                  = proto.pattern;
-			params.blink_color = Color::from_proto(proto.blink_color);
+		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.blink_period_ms                 = proto.blink_period_ms;
+		params.repeat_count             = proto.repeat_count;
-		params.rainbow_move_speed_leds_per_sec = proto.rainbow_move_speed_leds_per_sec;
+		if (proto.has_random_seed) {
-		params.segment_led_start               = proto.segment_led_start;
+			params.random_seed = proto.random_seed;
-		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.pattern                  = pattern;
-		proto.blink_color                     = blink_color.to_proto();
+		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.blink_period_ms                 = blink_period_ms;
+		proto.repeat_count             = repeat_count;
-		proto.rainbow_move_speed_leds_per_sec = rainbow_move_speed_leds_per_sec;
+		if (random_seed.has_value()) {
-		proto.segment_led_start               = segment_led_start;
+			proto.has_random_seed = true;
-		proto.segment_led_count               = segment_led_count;
+			proto.random_seed     = *random_seed;
-		proto.highlight_last_n_leds           = highlight_last_n_leds;
+		}
-		proto.blink_palette_index             = blink_palette_index;
 		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{"<palette>"};
 		ESP_LOG_LEVEL(level, tag,
-					  "TrackTestParameters{"
+					  "TrackDisplayTestParameters{"
-					  ".blink_color=%s, "
+					  ".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 ", "
+					  ".repeat_count=%" PRIu16 ", "
-					  ".rainbow_move_speed_leds_per_sec=%" PRIu32 ", "
+					  ".has_random_seed=%d, "
-					  ".segment_led_start=%" PRIu16 ", "
+					  ".random_seed=%" PRIu32 "}",
-					  ".segment_led_count=%" PRIu16 ", "
+					  pattern_to_str(pattern),
-					  ".highlight_last_n_leds=%" PRIu16 ", "
+					  effect_to_str(effect),
-					  ".blink_palette_index=%" PRIu8 "}",
+					  palette_index,
-					  blink_color.string().c_str(),
+					  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,
+					  repeat_count,
-					  rainbow_move_speed_leds_per_sec,
+					  random_seed.has_value(),
-					  segment_led_start,
+					  random_seed.value_or(0));
-					  segment_led_count,
-					  highlight_last_n_leds,
-					  blink_palette_index);
 	}
 };
 
@@ -868,16 +940,16 @@ struct TrackControlMsg {
 	static inline const pb_msgdesc_t *pb_fields = &track_app_TrackControlMsg_msg;
 
 	/** properties */
-	std::variant<unit, TrackState, TrackTestParameters, TrackControllerMode> state{unit{}};
+	std::variant<unit, TrackState, TrackDisplayTestParameters, TrackControllerMode> 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<TrackState>(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<TrackControllerMode>(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_app_TrackState>(track_state);
 					   },
-					   [&](const TrackTestParameters &test_params) {
+					   [&](const TrackDisplayTestParameters &test_params) {
-						   proto.which_msg               = track_app_TrackControlMsg_set_test_parameters_tag;
+						   proto.which_msg                           = track_app_TrackControlMsg_set_display_test_parameters_tag;
-						   proto.msg.set_test_parameters = test_params.to_proto();
+						   proto.msg.set_display_test_parameters = test_params.to_proto();
 					   },
 					   [&](TrackControllerMode mode) {
 						   proto.which_msg    = track_app_TrackControlMsg_set_mode_tag;

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 {

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:
+	case track_app_TrackState_TEST_DISPLAY:
-		return track_core::TrackState::test_blink;
+		return track_core::TrackState::test_display;
 	}
 	return track_core::TrackState::stop;
 }

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:
+	case track_app_TrackState_TEST_DISPLAY:
-		return "TEST_BLINK";
+		return "TEST_DISPLAY";
 	}
 	return "UNKNOWN";
 }

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_<track_core::Color>(m, "Color")
         .def(nb::init<>())