refactor: remove static variables in members

Author: ravinrabbid

include/peripherals/Display.h

@@ -10,6 +10,7 @@
 #include "hardware/i2c.h"
 
 #include <cstdint>
+#include <list>
 #include <memory>
 
 namespace Divacon::Peripherals {
@@ -30,16 +31,52 @@ class Display {
         Menu,
     };
 
+    class BpmCounter {
+      private:
+        class Buffer {
+          private:
+            std::list<uint16_t> m_buffer;
+            size_t m_size_limit;
+
+          public:
+            Buffer(size_t size_limit) : m_size_limit(size_limit) {};
+
+            void insert(uint16_t value);
+            void clear() { m_buffer.clear(); };
+
+            [[nodiscard]] uint16_t getAvarage() const;
+        };
+
+        static constexpr size_t WINDOW_SIZE = 20;
+        static constexpr uint32_t DOUBLE_HIT_TIMEOUT_MS = 50;
+
+        uint32_t m_timeout_ms;
+        Buffer m_buffer{WINDOW_SIZE};
+
+        Utils::InputState::Buttons m_prev_buttons{};
+        uint32_t m_prev_press_time{0};
+
+        uint16_t m_current_bpm{0};
+
+      public:
+        BpmCounter(uint32_t timeout_ms) : m_timeout_ms(timeout_ms) {};
+        void update(const Utils::InputState::Buttons &buttons);
+
+        [[nodiscard]] uint16_t getBpm() const { return m_current_bpm; };
+    };
+
     Config m_config;
     State m_state{State::Idle};
 
     uint32_t m_touched{0};
-    Utils::InputState::Buttons m_buttons{};
     usb_mode_t m_usb_mode{USB_MODE_DEBUG};
     uint8_t m_player_id{0};
     Utils::Menu::State m_menu_state{};
 
     ssd1306_t m_display{};
+    uint32_t m_next_frame_time{0};
+
+    BpmCounter m_bpm_counter{2000};
 
     void drawIdleScreen();
     void drawMenuScreen();

include/peripherals/TouchSlider.h

@@ -105,16 +105,29 @@ class TouchSlider {
         uint32_t read() final;
     };
 
+    struct StickStates {
+        struct State {
+            uint8_t left_limit{0};
+            uint8_t right_limit{UINT8_MAX};
+            uint8_t value{Utils::InputState::AnalogStick::CENTER};
+        };
+
+        State left;
+        State right;
+    };
+
     Config m_config;
     usb_mode_t m_mode;
     uint32_t m_touched{0};
+    StickStates m_stick_states;
 
     std::unique_ptr<TouchControllerInterface> m_touch_controller;
+    uint32_t m_last_read_time{0};
 
     void read();
 
     void updateInputStateArcade(Utils::InputState &input_state) const;
-    void updateInputStateStick(Utils::InputState &input_state) const;
+    void updateInputStateStick(Utils::InputState &input_state);
 
   public:
     TouchSlider(const Config &config, usb_mode_t mode);

include/peripherals/TouchSliderLeds.h

@@ -11,7 +11,15 @@ namespace Divacon::Peripherals {
 
 class TouchSliderLeds {
   private:
-    const static size_t SEGMENT_COUNT = 32;
+    static constexpr size_t SEGMENT_COUNT = 32;
+
+    static constexpr uint32_t PULSE_STEPS = 4096;
+    static constexpr uint32_t RAINBOW_STEPS = 4096;
+    static constexpr uint32_t FADE_STEPS = 2048;
+    static constexpr uint32_t BLEND_STEPS = 128;
+
+    static constexpr uint8_t PULSE_DIM_PCT_MIN = 40;
+    static constexpr uint8_t PULSE_DIM_PCT_MAX = 100;
 
   public:
     struct Config {
@@ -59,10 +67,42 @@ class TouchSliderLeds {
     using RawFrameMessage = std::array<Config::Color, SEGMENT_COUNT>;
 
   private:
+    class AnimationStepper {
+      private:
+        uint32_t m_steps_until_advance;
+        uint32_t m_current_steps{0};
+
+      public:
+        AnimationStepper(uint32_t steps_until_advance) : m_steps_until_advance(steps_until_advance) {};
+        uint32_t getFrameCount(uint32_t steps);
+    };
+
     Config m_config;
     uint32_t m_touched{0};
 
+    struct {
+        AnimationStepper stepper{PULSE_STEPS};
+        uint8_t dim_percent{PULSE_DIM_PCT_MAX};
+        int8_t advance_factor{-1};
+    } m_pulse_state;
+
+    struct {
+        AnimationStepper stepper{RAINBOW_STEPS};
+        size_t position{0};
+    } m_rainbow_state;
+
+    struct {
+        AnimationStepper stepper{FADE_STEPS};
+        std::array<uint8_t, SEGMENT_COUNT> percent{};
+    } m_fade_state;
+
+    struct {
+        AnimationStepper stepper{BLEND_STEPS};
+        uint8_t percent{100};
+    } m_blend_state;
+
     std::vector<uint32_t> m_rendered_frame;
+    uint32_t m_previous_frame_time{0};
 
     std::array<Config::Color, SEGMENT_COUNT> m_idle_buffer{};
     std::array<Config::Color, SEGMENT_COUNT> m_touched_buffer{};

include/utils/InputState.h

@@ -19,7 +19,7 @@ struct InputState {
     };
 
     struct AnalogStick {
-        const static uint8_t CENTER = 0x80;
+        static constexpr uint8_t CENTER = 0x80;
 
         uint8_t x{CENTER}, y{CENTER};
     };

include/utils/Menu.h

@@ -115,9 +115,38 @@ class Menu {
     const static std::map<Page, const Descriptor> descriptors;
 
   private:
+    class Buttons {
+      public:
+        enum class Id : uint8_t { Left, Right, Confirm, Back };
+
+      private:
+        struct State {
+            enum class Repeat : uint8_t {
+                Idle,
+                RepeatDelay,
+                Repeat,
+                FastRepeat,
+            };
+            Repeat repeat;
+            uint32_t pressed_since;
+            uint32_t last_repeat;
+            bool pressed;
+        };
+
+        std::map<Id, State> m_states;
+
+      public:
+        Buttons();
+
+        void update(const InputState &state);
+        [[nodiscard]] bool getPressed(Id id) const;
+    };
+
     std::shared_ptr<SettingsStore> m_store;
+    Buttons m_buttons;
     bool m_active{false};
-    std::stack<State> m_state_stack;
+
+    std::stack<State> m_state_stack{{{.page = Page::Main, .selected_value = 0, .original_value = 0}}};
 
     uint8_t getCurrentValue(Page page);
     void gotoPage(Page page);

src/peripherals/Display.cpp

@@ -4,7 +4,6 @@
 #include "pico/time.h"
 
 #include <array>
-#include <list>
 #include <numeric>
 #include <string>
 
@@ -166,79 +165,56 @@ std::string modeToString(usb_mode_t mode) {
     return "?";
 }
 
-uint16_t calculateBpm(const Utils::InputState::Buttons &buttons) {
+} // namespace
+
+void Display::BpmCounter::Buffer::insert(uint16_t value) {
+    if (m_buffer.size() >= m_size_limit) {
+        m_buffer.pop_back();
+    }
+    m_buffer.push_front(value);
+}
+
+uint16_t Display::BpmCounter::Buffer::getAvarage() const {
+    if (!m_buffer.empty()) {
+        return std::accumulate(m_buffer.begin(), m_buffer.end(), 0) / m_buffer.size();
+    }
+    return 0;
+}
+
+void Display::BpmCounter::update(const Utils::InputState::Buttons &buttons) {
     // Somewhat ugly gimmick to calculate the how often the face buttons
     // are pressed per minute.
     //
-    // It records the average time between the last 'window_size' button
+    // It records the average time between the last 'WINDOW_SIZE' button
     // presses for calculation. To avoid spikes caused by simultaneous
-    // button presses, all presses within 'double_hit_window' are counted
+    // button presses, all presses within 'DOUBLE_HIT_TIMEOUT_MS' are counted
     // as a single press.
     //
-    // Counter resets after 'reset_after'.
-
-    static const size_t window_size = 20;
-    static const uint32_t double_hit_window = 50;
-    static const uint32_t reset_after = 2000;
-
-    static Utils::InputState::Buttons prev_buttons = {};
-    static uint32_t prev_press = 0;
-    static uint16_t current_bpm = 0;
-
-    struct StatBuffer {
-      private:
-        std::list<uint16_t> m_buf;
-        size_t m_max_size;
-
-      public:
-        StatBuffer(size_t max_size) : m_max_size(max_size) {}
-
-        void clear() { m_buf.clear(); };
-
-        void insert(uint16_t val) {
-            if (m_buf.size() >= m_max_size) {
-                m_buf.pop_back();
-            }
-            m_buf.push_front(val);
-        };
-
-        uint16_t avg() {
-            if (!m_buf.empty()) {
-                return std::accumulate(m_buf.begin(), m_buf.end(), 0) / m_buf.size();
-            }
-            return 0;
-        }
-    };
-    static StatBuffer stat_buffer(window_size);
-
+    // Counter resets after 'm_timeout_ms'.
     const uint32_t now = to_ms_since_boot(get_absolute_time());
-    const uint32_t interval = now - prev_press;
+    const uint32_t interval = now - m_prev_press_time;
 
-    if (interval > reset_after) {
-        stat_buffer.clear();
-        current_bpm = 0;
-        prev_press = 0;
+    if (interval > m_timeout_ms) {
+        m_buffer.clear();
+        m_current_bpm = 0;
+        m_prev_press_time = 0;
     }
 
-    if ((interval > double_hit_window) &&
-        ((buttons.north && !prev_buttons.north) || (buttons.east && !prev_buttons.east) ||
-         (buttons.south && !prev_buttons.south) || (buttons.west && !prev_buttons.west))) {
+    if ((interval > DOUBLE_HIT_TIMEOUT_MS) &&
+        ((buttons.north && !m_prev_buttons.north) || (buttons.east && !m_prev_buttons.east) ||
+         (buttons.south && !m_prev_buttons.south) || (buttons.west && !m_prev_buttons.west))) {
 
-        if (prev_press != 0) {
-            stat_buffer.insert(interval);
-            current_bpm = 60000 / stat_buffer.avg();
+        if (m_prev_press_time != 0) {
+            m_buffer.insert(interval);
+            m_current_bpm = 60000 / m_buffer.getAvarage();
         }
 
-        prev_press = now;
+        m_prev_press_time = now;
     }
 
-    prev_buttons = buttons;
-
-    return current_bpm;
+    m_prev_buttons = buttons;
 }
 
-} // namespace
-
 Display::Display(const Config &config) : m_config(config) {
     i2c_init(m_config.i2c_block, m_config.i2c_speed_hz);
     gpio_set_function(m_config.sda_pin, GPIO_FUNC_I2C);
@@ -252,7 +228,7 @@ Display::Display(const Config &config) : m_config(config) {
 }
 
 void Display::setTouched(uint32_t touched) { m_touched = touched; }
-void Display::setButtons(const Utils::InputState::Buttons &buttons) { m_buttons = buttons; }
+void Display::setButtons(const Utils::InputState::Buttons &buttons) { m_bpm_counter.update(buttons); }
 void Display::setUsbMode(usb_mode_t mode) { m_usb_mode = mode; };
 void Display::setPlayerId(uint8_t player_id) { m_player_id = player_id; };
 
@@ -268,7 +244,7 @@ void Display::drawIdleScreen() {
     ssd1306_draw_line(&m_display, 0, 10, 128, 10);
 
     // BPM
-    auto bpm_str = std::to_string(calculateBpm(m_buttons)) + " bpm";
+    auto bpm_str = std::to_string(m_bpm_counter.getBpm()) + " bpm";
     ssd1306_draw_string(&m_display, (127 - (bpm_str.length() * 12)) / 2, 20, 2, bpm_str.c_str());
 
     // Player "LEDs"
@@ -360,13 +336,12 @@ void Display::drawMenuScreen() {
 }
 
 void Display::update() {
-    static const uint32_t interval_ms = 20; // Limit to ~50fps
-    static uint32_t start_ms = 0;
+    static const uint32_t interval_ms = 17; // Limit to ~60fps
 
-    if (to_ms_since_boot(get_absolute_time()) - start_ms < interval_ms) {
+    if (to_ms_since_boot(get_absolute_time()) - m_next_frame_time < interval_ms) {
         return;
     }
-    start_ms += interval_ms;
+    m_next_frame_time += interval_ms;
 
     ssd1306_clear(&m_display);