Added display to calibrate other buttons

main/CMakeLists.txt

@@ -136,6 +136,7 @@ set(headers
     displays/menus/enablemenu.h
     displays/menus/espnowmenu.h
     displays/menus/espnowsettingsmenu.h
+    displays/menus/extrabuttoncalibratemenu.h
     displays/menus/feedbackdebugmenu.h
     displays/menus/gametrakmodesettingsmenu.h
     displays/menus/garagenmenu.h
@@ -360,6 +361,7 @@ set(sources
     displays/menus/enablemenu.cpp
     displays/menus/espnowmenu.cpp
     displays/menus/espnowsettingsmenu.cpp
+    displays/menus/extrabuttoncalibratemenu.cpp
     displays/menus/feedbackdebugmenu.cpp
     displays/menus/gametrakmodesettingsmenu.cpp
     displays/menus/garagenmenu.cpp

main/accessors/settingsaccessors.h

@@ -238,3 +238,19 @@ struct ESPNowSyncTimeEnabledAccessor : public RefAccessorSaveSettings<bool> { bo
 struct ESPNowSyncTimeWithOthersEnabledAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.espnow.syncTimeWithOthers; } };
 struct ESPNowSyncBlinkEnabledAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.espnow.syncBlink; } };
 #endif
+
+// Button Mapping accessors
+struct ButtonLeftAccessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingLeft; } };
+struct ButtonRightAccessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingRight; } };
+struct ButtonUpAccessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingUp; } };
+struct ButtonDownAccessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingDown; } };
+
+struct ButtonLeft2Accessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingLeft2; } };
+struct ButtonRight2Accessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingRight2; } };
+struct ButtonUp2Accessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingUp2; } };
+struct ButtonDown2Accessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingDown2; } };
+
+struct ButtonProfile0Accessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingProfile0; } };
+struct ButtonProfile1Accessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingProfile1; } };
+struct ButtonProfile2Accessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingProfile2; } };
+struct ButtonProfile3Accessor : public NewSettingsAccessor<uint8_t> { ConfigWrapper<uint8_t> &getConfig() const override { return configs.dpadMappingProfile3; } };

main/displays/menus/boardcomputerhardwaresettingsmenu.cpp

@@ -18,10 +18,12 @@
 #include "displays/menus/timersmenu.h"
 #include "displays/menus/settingsmenu.h"
 #include "displays/buttoncalibratedisplay.h"
+#include "displays/menus/extrabuttoncalibratemenu.h"
 
 namespace {
 constexpr char TEXT_BOARDCOMPUTERHARDWARESETTINGS[] = "Boardcomputer H/W settings";
 constexpr char TEXT_BUTTONCALIBRATE[] = "Button Calibrate";
+constexpr char TEXT_EXTRABUTTONCALIBRATE[] = "Cal other Buttons";
 constexpr char TEXT_LOCKSCREENSETTINGS[] = "Lockscreen Settings";
 constexpr char TEXT_POTISCALIBRATE[] = "Potis Calibrate";
 constexpr char TEXT_SAMPLECOUNT[] = "sampleCount";
@@ -174,6 +176,7 @@ BoardcomputerHardwareSettingsMenu::BoardcomputerHardwareSettingsMenu()
 {
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOCKSCREENSETTINGS>,                          SwitchScreenAction<LockscreenSettingsMenu>, StaticMenuItemIcon<&bobbyicons::lock>>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BUTTONCALIBRATE>,                             SwitchScreenAction<ButtonCalibrateDisplay>>>();
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_EXTRABUTTONCALIBRATE>,                        SwitchScreenAction<ExtraButtonCalibrateMenu>>>();
     constructMenuItem<makeComponent<MenuItem, GasText,                                                      DisabledColor, StaticFont<2>, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, BremsText,                                                    DisabledColor, StaticFont<2>, DummyAction>>();
     constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTISCALIBRATE>,                              SwitchScreenAction<PotisCalibrateDisplay>>>();

main/displays/menus/extrabuttoncalibratemenu.cpp

@@ -0,0 +1,246 @@
+#include "extrabuttoncalibratemenu.h"
+
+// 3rd party includes
+#include <TFT_eSPI.h>
+#include <menuitem.h>
+#include <icons/back.h>
+#include <textwithvaluehelper.h>
+
+// local includes
+#include "esp_log.h"
+#include "accessors/settingsaccessors.h"
+#include "actions/switchscreenaction.h"
+#include "bobbyerrorhandler.h"
+#include "displays/menus/boardcomputerhardwaresettingsmenu.h"
+#include "globals.h"
+
+using namespace espgui;
+
+namespace {
+Status currentStatus;
+
+constexpr const char TAG[] = "BUTTON";
+
+constexpr char TEXT_EXTRABUTTONCALIBRATEMENU[] = "Calibrate Buttons";
+constexpr char TEXT_BUTTON_LEFT2[]  = "Left2";
+constexpr char TEXT_BUTTON_RIGHT2[] = "Right2";
+constexpr char TEXT_BUTTON_UP2[]    = "Up2";
+constexpr char TEXT_BUTTON_DOWN2[]  = "Down2";
+
+constexpr char TEXT_BUTTON_PROFILE0[] = "Profile0";
+constexpr char TEXT_BUTTON_PROFILE1[] = "Profile1";
+constexpr char TEXT_BUTTON_PROFILE2[] = "Profile2";
+constexpr char TEXT_BUTTON_PROFILE3[] = "Profile3";
+
+constexpr char TEXT_BACK[] = "Back";
+
+template<const char *Tprefix, typename Taccessor, Status status>
+class ButtonCalibrateMenuItem :
+        public MenuItem,
+        public TextWithValueHelper<Tprefix, Taccessor>
+{
+    using StandardText = TextWithValueHelper<Tprefix, Taccessor>;
+public:
+    void triggered() override
+    {
+        ESP_LOGI(TAG, "Pressed menu item for %s", Tprefix);
+        currentStatus = status;
+    }
+
+    int color() const override
+    {
+        return (status == currentStatus || currentStatus == Idle) ? TFT_WHITE : TFT_DARKGREY;
+    }
+
+    std::string text() const override
+    {
+        if (status == currentStatus)
+        {
+            return fmt::format("Press {}", Tprefix);
+        }
+        else
+        {
+            return StandardText::text();
+        }
+    }
+};
+
+} // namespace
+
+ExtraButtonCalibrateMenu::ExtraButtonCalibrateMenu()
+{
+    constructMenuItem<ButtonCalibrateMenuItem<TEXT_BUTTON_LEFT2, ButtonLeft2Accessor, Status::WaitingLeft2>>();
+    constructMenuItem<ButtonCalibrateMenuItem<TEXT_BUTTON_RIGHT2, ButtonRight2Accessor, Status::WaitingRight2>>();
+    constructMenuItem<ButtonCalibrateMenuItem<TEXT_BUTTON_UP2, ButtonUp2Accessor, Status::WaitingUp2>>();
+    constructMenuItem<ButtonCalibrateMenuItem<TEXT_BUTTON_DOWN2, ButtonDown2Accessor, Status::WaitingDown2>>();
+
+    constructMenuItem<ButtonCalibrateMenuItem<TEXT_BUTTON_PROFILE0, ButtonProfile0Accessor, Status::WaitingProfile0>>();
+    constructMenuItem<ButtonCalibrateMenuItem<TEXT_BUTTON_PROFILE1, ButtonProfile1Accessor, Status::WaitingProfile1>>();
+    constructMenuItem<ButtonCalibrateMenuItem<TEXT_BUTTON_PROFILE2, ButtonProfile2Accessor, Status::WaitingProfile2>>();
+    constructMenuItem<ButtonCalibrateMenuItem<TEXT_BUTTON_PROFILE3, ButtonProfile3Accessor, Status::WaitingProfile3>>();
+
+    constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
+}
+
+void ExtraButtonCalibrateMenu::start()
+{
+    Base::start();
+    m_oldMode = currentMode;
+    currentMode = &m_mode;
+    currentStatus = Idle;
+}
+
+void ExtraButtonCalibrateMenu::update()
+{
+    Base::update();
+}
+
+void ExtraButtonCalibrateMenu::stop()
+{
+    Base::stop();
+
+    if (currentMode == &m_mode)
+    {
+        m_mode.stop();
+        lastMode = nullptr;
+        currentMode = m_oldMode;
+    }
+}
+
+void ExtraButtonCalibrateMenu::rawButtonPressed(uint8_t button)
+{
+    if (currentStatus == Idle)
+    {
+        Base::rawButtonPressed(button);
+    }
+    else
+    {
+        if (validateNewButton(button))
+        {
+            ESP_LOGI(TAG, "Valid new button: %i", button);
+            switch(currentStatus)
+            {
+            case WaitingUp2:
+                if (auto result = configs.write_config(configs.dpadMappingUp2, button); !result)
+                {
+                    BobbyErrorHandler{}.errorOccured(std::move(result).error());
+                    break;
+                }
+                break;
+            case WaitingDown2:
+                if (auto result = configs.write_config(configs.dpadMappingDown2, button); !result)
+                {
+                    BobbyErrorHandler{}.errorOccured(std::move(result).error());
+                    break;
+                }
+                break;
+            case WaitingLeft2:
+                if (auto result = configs.write_config(configs.dpadMappingLeft2, button); !result)
+                {
+                    BobbyErrorHandler{}.errorOccured(std::move(result).error());
+                    break;
+                }
+                break;
+            case WaitingRight2:
+                if (auto result = configs.write_config(configs.dpadMappingRight2, button); !result)
+                {
+                    BobbyErrorHandler{}.errorOccured(std::move(result).error());
+                    break;
+                }
+                break;
+            case WaitingProfile0:
+                if (auto result = configs.write_config(configs.dpadMappingProfile0, button); !result)
+                {
+                    BobbyErrorHandler{}.errorOccured(std::move(result).error());
+                    break;
+                }
+                break;
+            case WaitingProfile1:
+                if (auto result = configs.write_config(configs.dpadMappingProfile1, button); !result)
+                {
+                    BobbyErrorHandler{}.errorOccured(std::move(result).error());
+                    break;
+                }
+                break;
+            case WaitingProfile2:
+                if (auto result = configs.write_config(configs.dpadMappingProfile2, button); !result)
+                {
+                    BobbyErrorHandler{}.errorOccured(std::move(result).error());
+                    break;
+                }
+                break;
+            case WaitingProfile3:
+                if (auto result = configs.write_config(configs.dpadMappingProfile3, button); !result)
+                {
+                    BobbyErrorHandler{}.errorOccured(std::move(result).error());
+                    break;
+                }
+                break;
+            default:
+                break;
+            }
+            currentStatus = Idle;
+        }
+        else
+        {
+            ESP_LOGE(TAG, "Invalid new button: %i", button);
+            currentStatus = Idle;
+        }
+    }
+}
+
+void ExtraButtonCalibrateMenu::rawButtonReleased(uint8_t button)
+{
+//    if (currentStatus == Idle)
+//    {
+//        Base::rawButtonReleased(button);
+//    }
+}
+
+void ExtraButtonCalibrateMenu::buttonPressed(espgui::Button button)
+{
+    if (currentStatus == Idle)
+    {
+        Base::buttonPressed(button);
+    }
+    else
+    {
+        switch (button)
+        {
+        case Left:
+            ESP_LOGI(TAG, "Canceling procedure");
+            currentStatus = Idle;
+            break;
+        default:
+            break;
+        }
+    }
+}
+
+void ExtraButtonCalibrateMenu::buttonReleased(espgui::Button button)
+{
+//    if (currentStatus == Idle)
+//    {
+//        Base::buttonReleased(button);
+//    }
+}
+
+std::string ExtraButtonCalibrateMenu::text() const
+{
+    return TEXT_EXTRABUTTONCALIBRATEMENU;
+}
+
+void ExtraButtonCalibrateMenu::back()
+{
+    switchScreen<BoardcomputerHardwareSettingsMenu>();
+}
+
+bool ExtraButtonCalibrateMenu::validateNewButton(uint8_t button)
+{
+    return (
+            button != configs.dpadMappingDown.value &&
+            button != configs.dpadMappingUp.value &&
+            button != configs.dpadMappingLeft.value &&
+            button != configs.dpadMappingRight.value
+    );
+}

main/displays/menus/extrabuttoncalibratemenu.h

@@ -0,0 +1,45 @@
+#pragma once
+
+// local includes
+#include "displays/bobbymenudisplay.h"
+#include "modeinterface.h"
+#include "modes/ignoreinputmode.h"
+
+namespace {
+enum Status : uint8_t
+{
+    Idle,
+    WaitingLeft2,
+    WaitingRight2,
+    WaitingUp2,
+    WaitingDown2,
+    WaitingProfile0,
+    WaitingProfile1,
+    WaitingProfile2,
+    WaitingProfile3
+};
+} // namespace
+
+class ExtraButtonCalibrateMenu :
+        public BobbyMenuDisplay
+{
+    using Base = BobbyMenuDisplay;
+public:
+    ExtraButtonCalibrateMenu();
+    std::string text() const override;
+    void back() override;
+
+    void start() override;
+    void update() override;
+    void stop() override;
+
+    void rawButtonPressed(uint8_t button) override;
+    void rawButtonReleased(uint8_t button) override;
+    void buttonPressed(espgui::Button button) override;
+    void buttonReleased(espgui::Button button) override;
+
+private:
+    ModeInterface *m_oldMode;
+    IgnoreInputMode m_mode{0, bobbycar::protocol::ControlType::FieldOrientedControl, bobbycar::protocol::ControlMode::Torque};
+    bool validateNewButton(uint8_t button);
+};