feedc0de/bobbycar-boardcomputer-firmware
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Add unified model mode
This commit is contained in:
Daniel Brunner
2020-06-05 23:40:46 +02:00
committed by GitHub
parent 85a3e88876 4d0efb7bd9
commit b40ee72e40
16 changed files with 234 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/changevaluedisplay.h
View File

@ -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"

69
src/changevaluedisplay_unifiedmodelmode.h Normal file
View File

@ -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();
}
}

20
src/displays/menus/defaultmodesettingsmenu.h
View File

@ -18,17 +18,10 @@ class ModesSettingsMenu;
}
namespace {
using DefaultModeCtrlTypChangeDisplay = makeComponent<
ChangeValueDisplay<ControlType>,
StaticText<TEXT_SETCONTROLTYPE>,
DefaultModeCtrlTypAccessor,
BackActionInterface<SwitchScreenAction<DefaultModeSettingsMenu>>,
SwitchScreenAction<DefaultModeSettingsMenu>
>;
using DefaultModeCtrlModChangeDisplay = makeComponent<
ChangeValueDisplay<ControlMode>,
StaticText<TEXT_SETCONTROLMODE>,
DefaultModeCtrlModAccessor,
using DefaultModeModelModeChangeDisplay = makeComponent<
ChangeValueDisplay<UnifiedModelMode>,
StaticText<TEXT_SETMODELMODE>,
DefaultModeModelModeAccessor,
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_SETCONTROLMODE>, SwitchScreenAction<DefaultModeCtrlModChangeDisplay>>,
makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHING>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingAccessor>,
makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<DefaultModeModelModeChangeDisplay>>,
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>>,

18
src/displays/menus/larsmmodesettingsmenu.h
View File

@ -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_LARSMMODECHANGEITERATIONS>, SwitchScreenAction<LarsmModeIterationsChangeDisplay>>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<LarsmModeModelModeChangeDisplay>>,
makeComponent<MenuItem, StaticText<TEXT_SETMODE>, SwitchScreenAction<LarsmModeModeChangeDisplay>>,
makeComponent<MenuItem, StaticText<TEXT_SETITERATIONS>, SwitchScreenAction<LarsmModeIterationsChangeDisplay>>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
>
{};
}

2
src/displays/menus/presetsmenu.h
View File

@ -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>>

20
src/displays/menus/tempomatmodesettingsmenu.h
View File

@ -16,17 +16,10 @@ class ModesSettingsMenu;
}
namespace {
using TempomatModeCtrlTypChangeScreen = makeComponent<
ChangeValueDisplay<ControlType>,
StaticText<TEXT_SETCONTROLMODE>,
TempomatModeCtrlTypAccessor,
BackActionInterface<SwitchScreenAction<TempomatModeSettingsMenu>>,
SwitchScreenAction<TempomatModeSettingsMenu>
>;
using TempomatModeCtrlModChangeScreen = makeComponent<
ChangeValueDisplay<ControlMode>,
StaticText<TEXT_SETCONTROLMODE>,
TempomatModeCtrlModAccessor,
using TempomatModeModelModeChangeScreen = makeComponent<
ChangeValueDisplay<UnifiedModelMode>,
StaticText<TEXT_SETMODELMODE>,
TempomatModeModelModeAccessor,
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_SETCONTROLMODE>, SwitchScreenAction<TempomatModeCtrlModChangeScreen>>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<TempomatModeModelModeChangeScreen>>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>
>
{};
}

5
src/modes/defaultmode.h
View File

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

5
src/modes/larsmmode.h
View File

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

5
src/modes/tempomatmode.h
View File

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

12
src/presets.h
View File

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

14
src/screens.h
View File

@ -144,8 +144,7 @@ union X {
WheelDiameterInchChangeScreen wheelDiameterInchChangeScreen;
NumMagnetPolesChangeScreen numMagnetPolesChangeScreen;
DefaultModeCtrlTypChangeDisplay changeDefaultModeCtrlTyp;
DefaultModeCtrlModChangeDisplay changeDefaultModeCtrlMod;
DefaultModeModelModeChangeDisplay changeDefaultModeModelMode;
DefaultModeSmoothingChangeDisplay changeDefaultModeSmoothing;
DefaultModeFrontPercentageChangeDisplay changeDefaultModeFrontPercentage;
DefaultModeBackPercentageChangeDisplay changeDefaultModeBackPercentage;
@ -155,9 +154,9 @@ union X {
DefaultModeBrems1WertChangeDisplay changeDefaultModeBrems1Wert;
DefaultModeBrems2WertChangeDisplay changeDefaultModeBrems2Wert;
TempomatModeCtrlTypChangeScreen changeManualModeCtrlTyp;
TempomatModeCtrlModChangeScreen changeManualModeCtrlMod;
TempomatModeModelModeChangeScreen changeManualModeModelMode;
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.changeDefaultModeCtrlMod) &getRefByType<decltype(displays.changeDefaultModeCtrlMod)>() { return displays.changeDefaultModeCtrlMod; }
template<> decltype(displays.changeDefaultModeModelMode) &getRefByType<decltype(displays.changeDefaultModeModelMode)>() { return displays.changeDefaultModeModelMode; }
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.changeManualModeCtrlMod) &getRefByType<decltype(displays.changeManualModeCtrlMod)>() { return displays.changeManualModeCtrlMod; }
template<> decltype(displays.changeManualModeModelMode) &getRefByType<decltype(displays.changeManualModeModelMode)>() { return displays.changeManualModeModelMode; }
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; }

15
src/settings.h
View File

@ -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;
ControlMode ctrlMod;
UnifiedModelMode modelMode;
bool enableSmoothing;
int16_t smoothing;
int16_t frontPercentage;
@ -64,11 +64,11 @@ struct Settings
} defaultMode;
struct TempomatMode {
ControlType ctrlTyp;
ControlMode ctrlMod;
UnifiedModelMode modelMode;
} 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.ctrlMod", defaultMode.ctrlMod);
callable("default.modelMo", defaultMode.modelMode);
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("tempomt.ctrlMod", tempomatMode.ctrlMod);
callable("tempoma.modelMo", tempomatMode.modelMode);
callable("larsm.modelMode", larsmMode.modelMode);
callable("larsm.mode", larsmMode.mode);
callable("larsm.iters", larsmMode.iterations);
}

7
src/settingsaccessors.h
View File

@ -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 DefaultModeCtrlModAccessor : public RefAccessorSaveSettings<ControlMode> { ControlMode &getRef() const override { return settings.defaultMode.ctrlMod; } };
struct DefaultModeModelModeAccessor : public RefAccessorSaveSettings<UnifiedModelMode> { UnifiedModelMode &getRef() const override { return settings.defaultMode.modelMode; } };
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 TempomatModeCtrlModAccessor : public RefAccessorSaveSettings<ControlMode> { ControlMode &getRef() const override { return settings.tempomatMode.ctrlMod; } };
struct TempomatModeModelModeAccessor : public RefAccessorSaveSettings<UnifiedModelMode> { UnifiedModelMode &getRef() const override { return settings.tempomatMode.modelMode; } };
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; } };
}

107
src/settingssaver.h
View File

@ -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;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = tempValue;
return err;
}};
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = tempValue;
return err;
}};
template<> struct nvsGetterHelper<ControlType> { static esp_err_t nvs_get(nvs_handle handle, const char* key, ControlType* out_value)
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = ControlType(tempValue);
return err;
}};
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = ControlType(tempValue);
return err;
}};
template<> struct nvsGetterHelper<ControlMode> { static esp_err_t nvs_get(nvs_handle handle, const char* key, ControlMode* out_value)
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = ControlMode(tempValue);
return err;
}};
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = ControlMode(tempValue);
return err;
}};
template<> struct nvsGetterHelper<LarsmModeMode> { static esp_err_t nvs_get(nvs_handle handle, const char* key, LarsmModeMode* out_value)
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = LarsmModeMode(tempValue);
return err;
}};
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = LarsmModeMode(tempValue);
return err;
}};
template<> struct nvsGetterHelper<BluetoothMode> { static esp_err_t nvs_get(nvs_handle handle, const char* key, BluetoothMode* out_value)
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = BluetoothMode(tempValue);
return err;
}};
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = BluetoothMode(tempValue);
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)
{

21
src/texts.h
View File

@ -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_SETCONTROLMODE[] = "Set control mode";
constexpr char TEXT_SETMODELMODE[] = "Set model 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_LARSMMODECHANGEITERATIONS[] = "Change iterations";
//constexpr char TEXT_SETMODELMODE[] = "Set model mode";
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_SETCONTROLMODE[] = "Set control mode";
//constexpr char TEXT_SETMODELMODE[] = "Set model 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";

34
src/unifiedmodelmode.h Normal file
View File

@ -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);
}
}