Merge pull request #53 from bobbycar-graz/51-unified-model-mode

Add unified model mode

src/changevaluedisplay.h

@@ -140,5 +140,6 @@ void ChangeValueDisplay<Tvalue>::confirm()
 #include "changevaluedisplay_controlmode.h"
 #include "changevaluedisplay_controltype.h"
 #include "changevaluedisplay_larsmmode_mode.h"
+#include "changevaluedisplay_unifiedmodelmode.h"
 #include "changevaluedisplay_wifi_mode_t.h"
 #include "changevaluedisplay_wifi_power_t.h"

src/changevaluedisplay_unifiedmodelmode.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "changevaluedisplay.h"
+#include "menudisplay.h"
+#include "staticmenudefinition.h"
+#include "utils.h"
+#include "actions/dummyaction.h"
+#include "icons/back.h"
+#include "texts.h"
+#include "unifiedmodelmode.h"
+
+namespace {
+template<>
+class ChangeValueDisplay<UnifiedModelMode> :
+    public MenuDisplay,
+    public StaticMenuDefinition<
+        makeComponent<MenuItem, StaticText<TEXT_COMMUTATION>, DummyAction>,
+        makeComponent<MenuItem, StaticText<TEXT_SINUSOIDAL>,  DummyAction>,
+        makeComponent<MenuItem, StaticText<TEXT_FOCVOLTAGE>,  DummyAction>,
+        makeComponent<MenuItem, StaticText<TEXT_FOCSPEED>,    DummyAction>,
+        makeComponent<MenuItem, StaticText<TEXT_FOCTORQUE>,   DummyAction>,
+        makeComponent<MenuItem, StaticText<TEXT_BACK>,        DummyAction, StaticMenuItemIcon<&icons::back>>
+    >,
+    public virtual AccessorInterface<UnifiedModelMode>,
+    public virtual ActionInterface
+{
+    using Base = MenuDisplay;
+
+public:
+    void start() override;
+
+    void itemPressed(int index) override;
+};
+
+void ChangeValueDisplay<UnifiedModelMode>::start()
+{
+    Base::start();
+
+    if (getValue() == UnifiedModelMode::Commutation)
+        setSelectedIndex(0);
+    else if (getValue() == UnifiedModelMode::Sinusoidal)
+        setSelectedIndex(1);
+    else if (getValue() == UnifiedModelMode::FocVoltage)
+        setSelectedIndex(2);
+    else if (getValue() == UnifiedModelMode::FocSpeed)
+        setSelectedIndex(3);
+    else if (getValue() == UnifiedModelMode::FocTorque)
+        setSelectedIndex(4);
+    else
+    {
+        Serial.printf("Unknown UnifiedModelMode: %i", int(getValue()));
+        setSelectedIndex(5);
+    }
+}
+
+void ChangeValueDisplay<UnifiedModelMode>::itemPressed(int index)
+{
+    switch (index)
+    {
+    case 0: setValue(UnifiedModelMode::Commutation); break;
+    case 1: setValue(UnifiedModelMode::Sinusoidal); break;
+    case 2: setValue(UnifiedModelMode::FocVoltage); break;
+    case 3: setValue(UnifiedModelMode::FocSpeed); break;
+    case 4: setValue(UnifiedModelMode::FocTorque); break;
+    }
+
+    triggered();
+}
+}

src/displays/menus/defaultmodesettingsmenu.h

@@ -18,17 +18,10 @@ class ModesSettingsMenu;
 }
 
 namespace {
-using DefaultModeCtrlTypChangeDisplay = makeComponent<
+using DefaultModeModelModeChangeDisplay = makeComponent<
-    ChangeValueDisplay<ControlType>,
+    ChangeValueDisplay<UnifiedModelMode>,
-    StaticText<TEXT_SETCONTROLTYPE>,
+    StaticText<TEXT_SETMODELMODE>,
-    DefaultModeCtrlTypAccessor,
+    DefaultModeModelModeAccessor,
-    BackActionInterface<SwitchScreenAction<DefaultModeSettingsMenu>>,
-    SwitchScreenAction<DefaultModeSettingsMenu>
->;
-using DefaultModeCtrlModChangeDisplay = makeComponent<
-    ChangeValueDisplay<ControlMode>,
-    StaticText<TEXT_SETCONTROLMODE>,
-    DefaultModeCtrlModAccessor,
     BackActionInterface<SwitchScreenAction<DefaultModeSettingsMenu>>,
     SwitchScreenAction<DefaultModeSettingsMenu>
 >;
@@ -94,9 +87,8 @@ class DefaultModeSettingsMenu :
     public StaticText<TEXT_DEFAULTMODESETTIGNS>,
     public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
     public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_SETCONTROLTYPE>,     SwitchScreenAction<DefaultModeCtrlTypChangeDisplay>>,
+        makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>,       SwitchScreenAction<DefaultModeModelModeChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETCONTROLMODE>,     SwitchScreenAction<DefaultModeCtrlModChangeDisplay>>,
+        makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHING>,    ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingAccessor>,
-        makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHING>,     ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingAccessor>,
         makeComponent<MenuItem, StaticText<TEXT_SETSMOOTHING>,       SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>,
         makeComponent<MenuItem, StaticText<TEXT_SETFRONTPERCENTAGE>, SwitchScreenAction<DefaultModeFrontPercentageChangeDisplay>>,
         makeComponent<MenuItem, StaticText<TEXT_SETBACKPERCENTAGE>,  SwitchScreenAction<DefaultModeBackPercentageChangeDisplay>>,

src/displays/menus/larsmmodesettingsmenu.h

@@ -16,16 +16,23 @@ class ModesSettingsMenu;
 }
 
 namespace {
+using LarsmModeModelModeChangeDisplay = makeComponent<
+    ChangeValueDisplay<UnifiedModelMode>,
+    StaticText<TEXT_SETMODELMODE>,
+    LarsmModeModelModeAccessor,
+    BackActionInterface<SwitchScreenAction<LarsmModeSettingsMenu>>,
+    SwitchScreenAction<LarsmModeSettingsMenu>
+>;
 using LarsmModeModeChangeDisplay = makeComponent<
     ChangeValueDisplay<LarsmModeMode>,
-    StaticText<TEXT_LARSMMODECHANGEMODE>,
+    StaticText<TEXT_SETMODE>,
     LarsmModeModeAccessor,
     BackActionInterface<SwitchScreenAction<LarsmModeSettingsMenu>>,
     SwitchScreenAction<LarsmModeSettingsMenu>
 >;
 using LarsmModeIterationsChangeDisplay = makeComponent<
     ChangeValueDisplay<uint8_t>,
-    StaticText<TEXT_LARSMMODECHANGEITERATIONS>,
+    StaticText<TEXT_SETITERATIONS>,
     LarsmModeIterationsAccessor,
     BackActionInterface<SwitchScreenAction<LarsmModeSettingsMenu>>,
     SwitchScreenAction<LarsmModeSettingsMenu>
@@ -36,9 +43,10 @@ class LarsmModeSettingsMenu :
     public StaticText<TEXT_LARSMMODESETTINGS>,
     public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
     public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_LARSMMODECHANGEMODE>,       SwitchScreenAction<LarsmModeModeChangeDisplay>>,
+        makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>,  SwitchScreenAction<LarsmModeModelModeChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_LARSMMODECHANGEITERATIONS>, SwitchScreenAction<LarsmModeIterationsChangeDisplay>>,
+        makeComponent<MenuItem, StaticText<TEXT_SETMODE>,       SwitchScreenAction<LarsmModeModeChangeDisplay>>,
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,                      SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
+        makeComponent<MenuItem, StaticText<TEXT_SETITERATIONS>, SwitchScreenAction<LarsmModeIterationsChangeDisplay>>,
+        makeComponent<MenuItem, StaticText<TEXT_BACK>,          SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
     >
 {};
 }

src/displays/menus/presetsmenu.h

@@ -79,7 +79,7 @@ class PresetsMenu :
         makeComponent<MenuItem, StaticText<TEXT_SPINNERCONTROLLERHARDWARE>,    ApplyControllerHardwarePresetAction<&presets::spinnerControllerHardware>>,
         makeComponent<MenuItem, StaticText<TEXT_DEFAULTBOARDCOMPUTERHARDWARE>, ApplyBoardcomputerHardwarePresetAction<&presets::defaultBoardcomputerHardware>>,
         makeComponent<MenuItem, StaticText<TEXT_DEFAULTDEFAULTMODE>,           ApplyDefaultModePresetAction<&presets::defaultDefaultMode>>,
-        makeComponent<MenuItem, StaticText<TEXT_SINUSODIALDEFAULTMODE>,        ApplyDefaultModePresetAction<&presets::sinusodialDefaultMode>>,
+        makeComponent<MenuItem, StaticText<TEXT_SINUSOIDALDEFAULTMODE>,        ApplyDefaultModePresetAction<&presets::sinusoidalDefaultMode>>,
         makeComponent<MenuItem, StaticText<TEXT_DEFAULTTEMPOMATMODE>,          ApplyTempomatModePresetAction<&presets::defaultTempomatMode>>,
         makeComponent<MenuItem, StaticText<TEXT_DEFAULTLARSMMODE>,             ApplyLarsmModePresetAction<&presets::defaultLarsmMode>>,
         makeComponent<MenuItem, StaticText<TEXT_BACK>,                         SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>

src/displays/menus/tempomatmodesettingsmenu.h

@@ -16,17 +16,10 @@ class ModesSettingsMenu;
 }
 
 namespace {
-using TempomatModeCtrlTypChangeScreen = makeComponent<
+using TempomatModeModelModeChangeScreen = makeComponent<
-    ChangeValueDisplay<ControlType>,
+    ChangeValueDisplay<UnifiedModelMode>,
-    StaticText<TEXT_SETCONTROLMODE>,
+    StaticText<TEXT_SETMODELMODE>,
-    TempomatModeCtrlTypAccessor,
+    TempomatModeModelModeAccessor,
-    BackActionInterface<SwitchScreenAction<TempomatModeSettingsMenu>>,
-    SwitchScreenAction<TempomatModeSettingsMenu>
->;
-using TempomatModeCtrlModChangeScreen = makeComponent<
-    ChangeValueDisplay<ControlMode>,
-    StaticText<TEXT_SETCONTROLMODE>,
-    TempomatModeCtrlModAccessor,
     BackActionInterface<SwitchScreenAction<TempomatModeSettingsMenu>>,
     SwitchScreenAction<TempomatModeSettingsMenu>
 >;
@@ -36,9 +29,8 @@ class TempomatModeSettingsMenu :
     public StaticText<TEXT_TEMPOMATMODESETTINGS>,
     public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
     public StaticMenuDefinition<
-        makeComponent<MenuItem, StaticText<TEXT_SETCONTROLTYPE>, SwitchScreenAction<TempomatModeCtrlTypChangeScreen>>,
+        makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<TempomatModeModelModeChangeScreen>>,
-        makeComponent<MenuItem, StaticText<TEXT_SETCONTROLMODE>, SwitchScreenAction<TempomatModeCtrlModChangeScreen>>,
+        makeComponent<MenuItem, StaticText<TEXT_BACK>,         SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
-        makeComponent<MenuItem, StaticText<TEXT_BACK>,           SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
     >
 {};
 }

src/modes/defaultmode.h

@@ -78,8 +78,9 @@ void DefaultMode::update()
     for (Controller &controller : controllers())
         for (MotorState &motor : motorsInController(controller))
         {
-            motor.ctrlTyp = settings.defaultMode.ctrlTyp;
+            const auto pair = split(settings.defaultMode.modelMode);
-            motor.ctrlMod = settings.defaultMode.ctrlMod;
+            motor.ctrlTyp = pair.first;
+            motor.ctrlMod = pair.second;
             motor.pwm = pwm / 100. * (&controller == &front ? settings.defaultMode.frontPercentage : settings.defaultMode.backPercentage);
         }
 

src/modes/larsmmode.h

@@ -98,8 +98,9 @@ void LarsmMode::update()
 
     for (MotorState &motor : motors())
     {
-        motor.ctrlTyp = ControlType::Commutation;
+        const auto pair = split(settings.larsmMode.modelMode);
-        motor.ctrlMod = ControlMode::Voltage;
+        motor.ctrlTyp = pair.first;
+        motor.ctrlMod = pair.second;
         motor.pwm = speed + weak;
     }
 

src/modes/tempomatmode.h

@@ -45,8 +45,9 @@ void TempomatMode::update()
 
     for (MotorState &motor : motors())
     {
-        motor.ctrlTyp = settings.tempomatMode.ctrlTyp;
+        const auto pair = split(settings.tempomatMode.modelMode);
-        motor.ctrlMod = settings.tempomatMode.ctrlMod;
+        motor.ctrlTyp = pair.first;
+        motor.ctrlMod = pair.second;
         motor.pwm = pwm;
     }
 

src/presets.h

@@ -85,8 +85,7 @@ constexpr Settings::BoardcomputerHardware defaultBoardcomputerHardware {
 };
 
 constexpr Settings::DefaultMode defaultDefaultMode {
-    .ctrlTyp = ControlType::FieldOrientedControl,
+    .modelMode = UnifiedModelMode::FocTorque,
-    .ctrlMod = ControlMode::Torque,
     .enableSmoothing = true,
     .smoothing = 20,
     .frontPercentage = 100,
@@ -98,9 +97,8 @@ constexpr Settings::DefaultMode defaultDefaultMode {
     .brems2_wert = 750
 };
 
-constexpr Settings::DefaultMode sinusodialDefaultMode {
+constexpr Settings::DefaultMode sinusoidalDefaultMode {
-    .ctrlTyp = ControlType::Sinusoidal,
+    .modelMode = UnifiedModelMode::Sinusoidal,
-    .ctrlMod = ControlMode::Voltage,
     .enableSmoothing = true,
     .smoothing = 20,
     .frontPercentage = 100,
@@ -113,11 +111,11 @@ constexpr Settings::DefaultMode sinusodialDefaultMode {
 };
 
 constexpr Settings::TempomatMode defaultTempomatMode {
-    .ctrlTyp = ControlType::FieldOrientedControl,
+    .modelMode = UnifiedModelMode::FocSpeed
-    .ctrlMod = ControlMode::Speed
 };
 
 constexpr Settings::LarsmMode defaultLarsmMode {
+    .modelMode = UnifiedModelMode::Commutation,
     .mode = LarsmModeMode::Mode4,
     .iterations = 100
 };

src/screens.h

@@ -144,8 +144,7 @@ union X {
     WheelDiameterInchChangeScreen wheelDiameterInchChangeScreen;
     NumMagnetPolesChangeScreen numMagnetPolesChangeScreen;
 
-    DefaultModeCtrlTypChangeDisplay changeDefaultModeCtrlTyp;
+    DefaultModeModelModeChangeDisplay changeDefaultModeModelMode;
-    DefaultModeCtrlModChangeDisplay changeDefaultModeCtrlMod;
     DefaultModeSmoothingChangeDisplay changeDefaultModeSmoothing;
     DefaultModeFrontPercentageChangeDisplay changeDefaultModeFrontPercentage;
     DefaultModeBackPercentageChangeDisplay changeDefaultModeBackPercentage;
@@ -155,9 +154,9 @@ union X {
     DefaultModeBrems1WertChangeDisplay changeDefaultModeBrems1Wert;
     DefaultModeBrems2WertChangeDisplay changeDefaultModeBrems2Wert;
 
-    TempomatModeCtrlTypChangeScreen changeManualModeCtrlTyp;
+    TempomatModeModelModeChangeScreen changeManualModeModelMode;
-    TempomatModeCtrlModChangeScreen changeManualModeCtrlMod;
 
+    LarsmModeModelModeChangeDisplay larsmModeModelModeChangeDisplay;
     LarsmModeModeChangeDisplay larsmModeModeChangeDisplay;
     LarsmModeIterationsChangeDisplay larsmModeIterationsChangeDisplay;
 
@@ -285,8 +284,7 @@ template<> decltype(displays.wheelDiameterMmChangeScreen)                      &
 template<> decltype(displays.wheelDiameterInchChangeScreen)                    &getRefByType<decltype(displays.wheelDiameterInchChangeScreen)>()                    { return displays.wheelDiameterInchChangeScreen; }
 template<> decltype(displays.numMagnetPolesChangeScreen)                       &getRefByType<decltype(displays.numMagnetPolesChangeScreen)>()                       { return displays.numMagnetPolesChangeScreen; }
 
-template<> decltype(displays.changeDefaultModeCtrlTyp)                         &getRefByType<decltype(displays.changeDefaultModeCtrlTyp)>()                         { return displays.changeDefaultModeCtrlTyp; }
+template<> decltype(displays.changeDefaultModeModelMode)                       &getRefByType<decltype(displays.changeDefaultModeModelMode)>()                       { return displays.changeDefaultModeModelMode; }
-template<> decltype(displays.changeDefaultModeCtrlMod)                         &getRefByType<decltype(displays.changeDefaultModeCtrlMod)>()                         { return displays.changeDefaultModeCtrlMod; }
 template<> decltype(displays.changeDefaultModeSmoothing)                       &getRefByType<decltype(displays.changeDefaultModeSmoothing)>()                       { return displays.changeDefaultModeSmoothing; }
 template<> decltype(displays.changeDefaultModeFrontPercentage)                 &getRefByType<decltype(displays.changeDefaultModeFrontPercentage)>()                 { return displays.changeDefaultModeFrontPercentage; }
 template<> decltype(displays.changeDefaultModeBackPercentage)                  &getRefByType<decltype(displays.changeDefaultModeBackPercentage)>()                  { return displays.changeDefaultModeBackPercentage; }
@@ -296,9 +294,9 @@ template<> decltype(displays.changeDefaultModeGas2Wert)                        &
 template<> decltype(displays.changeDefaultModeBrems1Wert)                      &getRefByType<decltype(displays.changeDefaultModeBrems1Wert)>()                      { return displays.changeDefaultModeBrems1Wert; }
 template<> decltype(displays.changeDefaultModeBrems2Wert)                      &getRefByType<decltype(displays.changeDefaultModeBrems2Wert)>()                      { return displays.changeDefaultModeBrems2Wert; }
 
-template<> decltype(displays.changeManualModeCtrlTyp)                          &getRefByType<decltype(displays.changeManualModeCtrlTyp)>()                          { return displays.changeManualModeCtrlTyp; }
+template<> decltype(displays.changeManualModeModelMode)                        &getRefByType<decltype(displays.changeManualModeModelMode)>()                        { return displays.changeManualModeModelMode; }
-template<> decltype(displays.changeManualModeCtrlMod)                          &getRefByType<decltype(displays.changeManualModeCtrlMod)>()                          { return displays.changeManualModeCtrlMod; }
 
+template<> decltype(displays.larsmModeModelModeChangeDisplay)                  &getRefByType<decltype(displays.larsmModeModelModeChangeDisplay)>()                  { return displays.larsmModeModelModeChangeDisplay; }
 template<> decltype(displays.larsmModeModeChangeDisplay)                       &getRefByType<decltype(displays.larsmModeModeChangeDisplay)>()                       { return displays.larsmModeModeChangeDisplay; }
 template<> decltype(displays.larsmModeIterationsChangeDisplay)                 &getRefByType<decltype(displays.larsmModeIterationsChangeDisplay)>()                 { return displays.larsmModeIterationsChangeDisplay; }
 

src/settings.h

@@ -5,6 +5,7 @@
 #include "bobbycar-protocol/protocol.h"
 
 #include "bluetoothmode.h"
+#include "unifiedmodelmode.h"
 
 namespace {
 enum class LarsmModeMode : uint8_t { Mode1, Mode2, Mode3, Mode4 };
@@ -50,8 +51,7 @@ struct Settings
     } boardcomputerHardware;
 
     struct DefaultMode {
-        ControlType ctrlTyp;
+        UnifiedModelMode modelMode;
-        ControlMode ctrlMod;
         bool enableSmoothing;
         int16_t smoothing;
         int16_t frontPercentage;
@@ -64,11 +64,11 @@ struct Settings
     } defaultMode;
 
     struct TempomatMode {
-        ControlType ctrlTyp;
+        UnifiedModelMode modelMode;
-        ControlMode ctrlMod;
     } tempomatMode;
 
     struct LarsmMode {
+        UnifiedModelMode modelMode;
         LarsmModeMode mode;
         uint8_t iterations;
     } larsmMode;
@@ -126,8 +126,7 @@ void Settings::executeForEverySetting(T &&callable)
 #endif
     callable("swapScreenBytes", boardcomputerHardware.swapScreenBytes);
 
-    callable("default.ctrlTyp", defaultMode.ctrlTyp);
+    callable("default.modelMo", defaultMode.modelMode);
-    callable("default.ctrlMod", defaultMode.ctrlMod);
     callable("default.enableS", defaultMode.enableSmoothing);
     callable("default.smoothi", defaultMode.smoothing);
     callable("default.frontPe", defaultMode.frontPercentage);
@@ -138,9 +137,9 @@ void Settings::executeForEverySetting(T &&callable)
     callable("default.brems1_", defaultMode.brems1_wert);
     callable("default.brems2_", defaultMode.brems2_wert);
 
-    callable("tempoma.ctrlTyp", tempomatMode.ctrlTyp);
+    callable("tempoma.modelMo", tempomatMode.modelMode);
-    callable("tempomt.ctrlMod", tempomatMode.ctrlMod);
 
+    callable("larsm.modelMode", larsmMode.modelMode);
     callable("larsm.mode", larsmMode.mode);
     callable("larsm.iters", larsmMode.iterations);
 }

src/settingsaccessors.h

@@ -70,8 +70,7 @@ struct GametrakDistMaxAccessor : public RefAccessorSaveSettings<int16_t> { int16
 #endif
 struct SwapScreenBytesAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.boardcomputerHardware.swapScreenBytes; } };
 
-struct DefaultModeCtrlTypAccessor : public RefAccessorSaveSettings<ControlType> { ControlType &getRef() const override { return settings.defaultMode.ctrlTyp; } };
+struct DefaultModeModelModeAccessor : public RefAccessorSaveSettings<UnifiedModelMode> { UnifiedModelMode &getRef() const override { return settings.defaultMode.modelMode; } };
-struct DefaultModeCtrlModAccessor : public RefAccessorSaveSettings<ControlMode> { ControlMode &getRef() const override { return settings.defaultMode.ctrlMod; } };
 struct DefaultModeEnableSmoothingAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.defaultMode.enableSmoothing; } };
 struct DefaultModeSmoothingAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.defaultMode.smoothing; } };
 struct DefaultModeFrontPercentageAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.defaultMode.frontPercentage; } };
@@ -82,9 +81,9 @@ struct DefaultModeGas2WertAccessor : public RefAccessorSaveSettings<int16_t> { i
 struct DefaultModeBrems1WertAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.defaultMode.brems1_wert; } };
 struct DefaultModeBrems2WertAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.defaultMode.brems2_wert; } };
 
-struct TempomatModeCtrlTypAccessor : public RefAccessorSaveSettings<ControlType> { ControlType &getRef() const override { return settings.tempomatMode.ctrlTyp; } };
+struct TempomatModeModelModeAccessor : public RefAccessorSaveSettings<UnifiedModelMode> { UnifiedModelMode &getRef() const override { return settings.tempomatMode.modelMode; } };
-struct TempomatModeCtrlModAccessor : public RefAccessorSaveSettings<ControlMode> { ControlMode &getRef() const override { return settings.tempomatMode.ctrlMod; } };
 
+struct LarsmModeModelModeAccessor : public RefAccessorSaveSettings<UnifiedModelMode> { UnifiedModelMode &getRef() const override { return settings.larsmMode.modelMode; } };
 struct LarsmModeModeAccessor : public RefAccessorSaveSettings<LarsmModeMode> { LarsmModeMode &getRef() const override { return settings.larsmMode.mode; } };
 struct LarsmModeIterationsAccessor : public RefAccessorSaveSettings<uint8_t> { uint8_t &getRef() const override { return settings.larsmMode.iterations; } };
 }

src/settingssaver.h

@@ -8,6 +8,7 @@
 
 #include "settings.h"
 #include "bluetoothmode.h"
+#include "unifiedmodelmode.h"
 
 namespace {
 class SettingsSaver
@@ -61,45 +62,53 @@ template<> struct nvsGetterHelper<uint16_t> { static constexpr auto nvs_get = &n
 template<> struct nvsGetterHelper<int32_t> { static constexpr auto nvs_get = &nvs_get_i32; };
 template<> struct nvsGetterHelper<uint32_t> { static constexpr auto nvs_get = &nvs_get_u32; };
 template<> struct nvsGetterHelper<bool> { static esp_err_t nvs_get(nvs_handle handle, const char* key, bool* out_value)
-    {
+{
-        uint8_t tempValue;
+    uint8_t tempValue;
-        esp_err_t err = nvs_get_u8(handle, key, &tempValue);
+    esp_err_t err = nvs_get_u8(handle, key, &tempValue);
-        if (err == ESP_OK)
+    if (err == ESP_OK)
-            *out_value = tempValue;
+        *out_value = tempValue;
-        return err;
+    return err;
-    }};
+}};
 template<> struct nvsGetterHelper<ControlType> { static esp_err_t nvs_get(nvs_handle handle, const char* key, ControlType* out_value)
-    {
+{
-        uint8_t tempValue;
+    uint8_t tempValue;
-        esp_err_t err = nvs_get_u8(handle, key, &tempValue);
+    esp_err_t err = nvs_get_u8(handle, key, &tempValue);
-        if (err == ESP_OK)
+    if (err == ESP_OK)
-            *out_value = ControlType(tempValue);
+        *out_value = ControlType(tempValue);
-        return err;
+    return err;
-    }};
+}};
 template<> struct nvsGetterHelper<ControlMode> { static esp_err_t nvs_get(nvs_handle handle, const char* key, ControlMode* out_value)
-    {
+{
-        uint8_t tempValue;
+    uint8_t tempValue;
-        esp_err_t err = nvs_get_u8(handle, key, &tempValue);
+    esp_err_t err = nvs_get_u8(handle, key, &tempValue);
-        if (err == ESP_OK)
+    if (err == ESP_OK)
-            *out_value = ControlMode(tempValue);
+        *out_value = ControlMode(tempValue);
-        return err;
+    return err;
-    }};
+}};
 template<> struct nvsGetterHelper<LarsmModeMode> { static esp_err_t nvs_get(nvs_handle handle, const char* key, LarsmModeMode* out_value)
-    {
+{
-        uint8_t tempValue;
+    uint8_t tempValue;
-        esp_err_t err = nvs_get_u8(handle, key, &tempValue);
+    esp_err_t err = nvs_get_u8(handle, key, &tempValue);
-        if (err == ESP_OK)
+    if (err == ESP_OK)
-            *out_value = LarsmModeMode(tempValue);
+        *out_value = LarsmModeMode(tempValue);
-        return err;
+    return err;
-    }};
+}};
 template<> struct nvsGetterHelper<BluetoothMode> { static esp_err_t nvs_get(nvs_handle handle, const char* key, BluetoothMode* out_value)
-    {
+{
-        uint8_t tempValue;
+    uint8_t tempValue;
-        esp_err_t err = nvs_get_u8(handle, key, &tempValue);
+    esp_err_t err = nvs_get_u8(handle, key, &tempValue);
-        if (err == ESP_OK)
+    if (err == ESP_OK)
-            *out_value = BluetoothMode(tempValue);
+        *out_value = BluetoothMode(tempValue);
-        return err;
+    return err;
-    }};
+}};
+template<> struct nvsGetterHelper<UnifiedModelMode> { static esp_err_t nvs_get(nvs_handle handle, const char* key, UnifiedModelMode* out_value)
+{
+    uint8_t tempValue;
+    esp_err_t err = nvs_get_u8(handle, key, &tempValue);
+    if (err == ESP_OK)
+        *out_value = UnifiedModelMode(tempValue);
+    return err;
+}};
 
 bool SettingsSaver::load(Settings &settings)
 {
@@ -127,21 +136,25 @@ template<> struct nvsSetterHelper<int32_t> { static constexpr auto nvs_set = &nv
 template<> struct nvsSetterHelper<uint32_t> { static constexpr auto nvs_set = &nvs_set_u32; };
 template<> struct nvsSetterHelper<bool> { static constexpr auto nvs_set = &nvs_set_u8; };
 template<> struct nvsSetterHelper<ControlType> { static esp_err_t nvs_set(nvs_handle handle, const char* key, ControlType value)
-    {
+{
-        return nvs_set_u8(handle, key, uint8_t(value));
+    return nvs_set_u8(handle, key, uint8_t(value));
-    }};
+}};
 template<> struct nvsSetterHelper<ControlMode> { static esp_err_t nvs_set(nvs_handle handle, const char* key, ControlMode value)
-    {
+{
-        return nvs_set_u8(handle, key, uint8_t(value));
+    return nvs_set_u8(handle, key, uint8_t(value));
-    }};
+}};
 template<> struct nvsSetterHelper<LarsmModeMode> { static esp_err_t nvs_set(nvs_handle handle, const char* key, LarsmModeMode value)
-    {
+{
-        return nvs_set_u8(handle, key, uint8_t(value));
+    return nvs_set_u8(handle, key, uint8_t(value));
-    }};
+}};
 template<> struct nvsSetterHelper<BluetoothMode> { static esp_err_t nvs_set(nvs_handle handle, const char* key, BluetoothMode value)
-    {
+{
-        return nvs_set_u8(handle, key, uint8_t(value));
+    return nvs_set_u8(handle, key, uint8_t(value));
-    }};
+}};
+template<> struct nvsSetterHelper<UnifiedModelMode> { static esp_err_t nvs_set(nvs_handle handle, const char* key, UnifiedModelMode value)
+{
+    return nvs_set_u8(handle, key, uint8_t(value));
+}};
 
 bool SettingsSaver::save(Settings &settings)
 {

src/texts.h

@@ -134,8 +134,7 @@ constexpr char TEXT_DYNAMICMENU[] = "Dynamic menu";
 
 //DefaultModeSettingsMenu
 //constexpr char TEXT_DEFAULTMODESETTINGS[] = "Default mode settings";
-constexpr char TEXT_SETCONTROLTYPE[] = "Set control type";
+constexpr char TEXT_SETMODELMODE[] = "Set model mode";
-constexpr char TEXT_SETCONTROLMODE[] = "Set control mode";
 constexpr char TEXT_ENABLESMOOTHING[] = "Enable smoothing";
 constexpr char TEXT_SETSMOOTHING[] = "Set smoothing";
 constexpr char TEXT_SETFRONTPERCENTAGE[] = "Set front percentage";
@@ -198,8 +197,9 @@ constexpr char TEXT_INVERTBACKRIGHT[] = "Invert back right";
 
 //LarsmModeSettingsMenu
 constexpr char TEXT_LARSMMODESETTINGS[] = "Larsm mode settings";
-constexpr char TEXT_LARSMMODECHANGEMODE[] = "Change mode";
+//constexpr char TEXT_SETMODELMODE[] = "Set model mode";
-constexpr char TEXT_LARSMMODECHANGEITERATIONS[] = "Change iterations";
+constexpr char TEXT_SETMODE[] = "Set mode";
+constexpr char TEXT_SETITERATIONS[] = "Set iterations";
 //constexpr char TEXT_BACK[] = "Back";
 
 //ModesSettingsMenu
@@ -218,8 +218,7 @@ constexpr char TEXT_MOSFET2[] = "Mosfet2";
 
 //TempomatModeSettingsMenu
 //constexpr char TEXT_TEMPOMATMODESETTINGS[] = "Tempomat mode settings";
-//constexpr char TEXT_SETCONTROLTYPE[] = "Set control type";
+//constexpr char TEXT_SETMODELMODE[] = "Set model mode";
-//constexpr char TEXT_SETCONTROLMODE[] = "Set control mode";
 //constexpr char TEXT_BACK[] = "Back";
 
 //WiFiSettingsMenu
@@ -256,7 +255,7 @@ constexpr char TEXT_MOSFETSOFFCONTROLLERHARDWARE[] = "MOSFETs off controller H/W
 constexpr char TEXT_SPINNERCONTROLLERHARDWARE[] = "Spinner controller H/W";
 constexpr char TEXT_DEFAULTBOARDCOMPUTERHARDWARE[] = "Default boardcomputer H/W";
 constexpr char TEXT_DEFAULTDEFAULTMODE[] = "Default defaultMode";
-constexpr char TEXT_SINUSODIALDEFAULTMODE[] = "Sinusodial defaultMode";
+constexpr char TEXT_SINUSOIDALDEFAULTMODE[] = "Sinusoidal defaultMode";
 constexpr char TEXT_DEFAULTTEMPOMATMODE[] = "Default tempomatMode";
 constexpr char TEXT_DEFAULTLARSMMODE[] = "Default larsmMode";
 constexpr char TEXT_STREET[] = "Street";
@@ -302,6 +301,14 @@ constexpr char TEXT_LARSMMODE3[] = "Mode3";
 constexpr char TEXT_LARSMMODE4[] = "Mode4";
 //constexpr char TEXT_BACK[] = "Back";
 
+//ChangeValueDisplay<UnifiedModelMode>
+//constexpr char TEXT_COMMUTATION[] = "Commutation";
+//constexpr char TEXT_SINUSOIDAL[] = "Sinusoidal";
+constexpr char TEXT_FOCVOLTAGE[] = "FOC/Voltage";
+constexpr char TEXT_FOCSPEED[] = "FOC/Speed";
+constexpr char TEXT_FOCTORQUE[] = "FOC/Torque";
+//constexpr char TEXT_BACK[] = "Back";
+
 //ChangeValueDisplay<wifi_mode_t>
 constexpr char TEXT_WIFI_MODE_NULL[] = "WIFI_MODE_NULL";
 constexpr char TEXT_WIFI_MODE_STA[] = "WIFI_MODE_STA";

src/unifiedmodelmode.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <utility>
+
+#include <HardwareSerial.h>
+
+#include "bobbycar-protocol/protocol.h"
+
+namespace {
+enum class UnifiedModelMode : uint8_t
+{
+    Commutation,
+    Sinusoidal,
+    FocVoltage,
+    FocSpeed,
+    FocTorque
+};
+
+std::pair<ControlType, ControlMode> split(UnifiedModelMode mode)
+{
+    switch (mode)
+    {
+    case UnifiedModelMode::Commutation: return std::make_pair(ControlType::Commutation, ControlMode::Voltage);
+    case UnifiedModelMode::Sinusoidal: return std::make_pair(ControlType::Sinusoidal, ControlMode::Voltage);
+    case UnifiedModelMode::FocVoltage: return std::make_pair(ControlType::FieldOrientedControl, ControlMode::Voltage);
+    case UnifiedModelMode::FocSpeed: return std::make_pair(ControlType::FieldOrientedControl, ControlMode::Speed);
+    case UnifiedModelMode::FocTorque: return std::make_pair(ControlType::FieldOrientedControl, ControlMode::Torque);
+    }
+
+    Serial.printf("Unknown UnifiedModelMode: %i\r\n", int(mode));
+
+    return std::make_pair(ControlType::FieldOrientedControl, ControlMode::OpenMode);
+}
+}