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

Merge pull request #72 from bobbycar-graz/minor-improvements

Browse Source 
Minor improvements
This commit is contained in:
Daniel Brunner
2020-06-28 04:45:38 +02:00
committed by GitHub
parent 3526523d9e 83229cd5c1
commit 9fb12587be
28 changed files with 764 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/actions/backproxyaction.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
#include "actioninterface.h"
namespace {
class BackProxyAction : public virtual ActionInterface
{
public:
BackProxyAction(BackInterface &backInterface) :
m_backInterface{backInterface}
{
}
void triggered() override
{
m_backInterface.back();
}
private:
BackInterface &m_backInterface;
};
}

38
src/actions/modesettingsaction.h Normal file
View File

@ -0,0 +1,38 @@
#pragma once
#include <HardwareSerial.h>
#include "actioninterface.h"
#include "globals.h"
#include "modes/defaultmode.h"
#include "modes/tempomatmode.h"
#include "modes/larsmmode.h"
#include "modes/gametrakmode.h"
#include "displays/menus/defaultmodesettingsmenu.h"
#include "displays/menus/tempomatmodesettingsmenu.h"
#include "displays/menus/larsmmodesettingsmenu.h"
#include "displays/menus/gametrakmodesettingsmenu.h"
namespace {
class ModeSettingsAction : public virtual ActionInterface
{
public:
void triggered() override;
};
void ModeSettingsAction::triggered()
{
if (currentMode == &modes::defaultMode)
switchScreen<DefaultModeSettingsMenu>();
else if (currentMode == &modes::tempomatMode)
switchScreen<TempomatModeSettingsMenu>();
else if (currentMode == &modes::larsmMode)
switchScreen<LarsmModeSettingsMenu>();
#ifdef FEATURE_GAMETRAK
else if (currentMode == &modes::gametrakMode)
switchScreen<GametrakModeSettingsMenu>();
#endif
else
Serial.println("Unknown mode, cannot open settings for it");
}
}

30
src/actions/setvalueaction.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
#include "actioninterface.h"
#include "accessorinterface.h"
namespace {
template<typename T>
class SetValueAction : public virtual ActionInterface
{
public:
SetValueAction(T value, AccessorInterface<T> &accessorInterface, BackInterface &backInterface) :
m_value{value},
m_accessorInterface{accessorInterface},
m_backInterface{backInterface}
{
}
void triggered() override
{
m_accessorInterface.setValue(m_value);
}
T value() const { return m_value; }
private:
const T m_value;
AccessorInterface<T> &m_accessorInterface;
BackInterface &m_backInterface;
};
}

8
src/bobby_webserver.h
View File

@ -177,7 +177,13 @@ void initWebserver()
return; return;
} }
menuDisplay->itemPressed(index); if (index < 0 || index >= menuDisplay->size())
{
webServer.send(400, "text/plain", "index out of range");
return;
}
menuDisplay->getMenuItem(index).triggered();
webServer.sendHeader("Connection", "close"); webServer.sendHeader("Connection", "close");
webServer.sendHeader("Location", "/"); webServer.sendHeader("Location", "/");

79
src/changevaluedisplay_bluetoothmode.h
View File

@ -4,7 +4,8 @@
#include "menudisplay.h" #include "menudisplay.h"
#include "staticmenudefinition.h" #include "staticmenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/dummyaction.h" #include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h" #include "icons/back.h"
#include "texts.h" #include "texts.h"
#include "bluetoothmode.h" #include "bluetoothmode.h"
@ -13,12 +14,6 @@ namespace {
template<> template<>
class ChangeValueDisplay<BluetoothMode> : class ChangeValueDisplay<BluetoothMode> :
public MenuDisplay, public MenuDisplay,
public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_OFF>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_MASTER>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_SLAVE>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, DummyAction, StaticMenuItemIcon<&icons::back>>
>,
public virtual AccessorInterface<BluetoothMode>, public virtual AccessorInterface<BluetoothMode>,
public virtual ActionInterface public virtual ActionInterface
{ {
@ -27,35 +22,65 @@ class ChangeValueDisplay<BluetoothMode> :
public: public:
void start() override; void start() override;
void itemPressed(int index) override; std::size_t size() const override { return 4; }
MenuItem& getMenuItem(std::size_t index) override
{
switch (index)
{
case 0: return m_offAction;
case 1: return m_masterAction;
case 2: return m_slaveAction;
case 3: return m_backItem;
}
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
switch (index)
{
case 0: return m_offAction;
case 1: return m_masterAction;
case 2: return m_slaveAction;
case 3: return m_backItem;
}
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{
callback(m_offAction);
callback(m_masterAction);
callback(m_slaveAction);
callback(m_backItem);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
{
callback(m_offAction);
callback(m_masterAction);
callback(m_slaveAction);
callback(m_backItem);
}
private:
makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_OFF>> m_offAction{BluetoothMode::Off, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_MASTER>> m_masterAction{BluetoothMode::Master, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_SLAVE>> m_slaveAction{BluetoothMode::Slave, *this, *this};
makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
}; };
void ChangeValueDisplay<BluetoothMode>::start() void ChangeValueDisplay<BluetoothMode>::start()
{ {
Base::start(); Base::start();
if (getValue() == BluetoothMode::Off) if (getValue() == m_offAction.value()) setSelectedIndex(0); else
setSelectedIndex(0); if (getValue() == m_masterAction.value()) setSelectedIndex(1); else
else if (getValue() == BluetoothMode::Master) if (getValue() == m_slaveAction.value()) setSelectedIndex(2); else
setSelectedIndex(1);
else if (getValue() == BluetoothMode::Slave)
setSelectedIndex(2);
else
{ {
Serial.printf("Unknown BluetoothMode: %i", int(getValue())); Serial.printf("Unknown BluetoothMode: %i", int(getValue()));
setSelectedIndex(4); setSelectedIndex(4);
} }
} }
void ChangeValueDisplay<BluetoothMode>::itemPressed(int index)
{
switch (index)
{
case 0: setValue(BluetoothMode::Off); break;
case 1: setValue(BluetoothMode::Master); break;
case 2: setValue(BluetoothMode::Slave); break;
}
triggered();
}
} }

68
src/changevaluedisplay_bool.h
View File

@ -5,7 +5,8 @@
#include "staticmenudefinition.h" #include "staticmenudefinition.h"
#include "actioninterface.h" #include "actioninterface.h"
#include "utils.h" #include "utils.h"
#include "actions/dummyaction.h" #include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h" #include "icons/back.h"
#include "texts.h" #include "texts.h"
@ -13,11 +14,6 @@ namespace {
template<> template<>
class ChangeValueDisplay<bool> : class ChangeValueDisplay<bool> :
public MenuDisplay, public MenuDisplay,
public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_TRUE>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_FALSE>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, DummyAction, StaticMenuItemIcon<&icons::back>>
>,
public virtual AccessorInterface<bool>, public virtual AccessorInterface<bool>,
public virtual ActionInterface public virtual ActionInterface
{ {
@ -26,27 +22,55 @@ class ChangeValueDisplay<bool> :
public: public:
void start() override; void start() override;
void itemPressed(int index) override; std::size_t size() const override { return 4; }
MenuItem& getMenuItem(std::size_t index) override
{
switch (index)
{
case 0: return m_trueItem;
case 1: return m_falseItem;
case 2: return m_backItem;
}
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
switch (index)
{
case 0: return m_trueItem;
case 1: return m_falseItem;
case 2: return m_backItem;
}
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{
callback(m_trueItem);
callback(m_falseItem);
callback(m_backItem);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
{
callback(m_trueItem);
callback(m_falseItem);
callback(m_backItem);
}
private:
makeComponentArgs<MenuItem, SetValueAction<bool>, StaticText<TEXT_TRUE>> m_trueItem{true, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<bool>, StaticText<TEXT_FALSE>> m_falseItem{false, *this, *this};
makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
}; };
void ChangeValueDisplay<bool>::start() void ChangeValueDisplay<bool>::start()
{ {
Base::start(); Base::start();
if (getValue() == true) if (getValue() == m_trueItem.value()) setSelectedIndex(0); else
setSelectedIndex(0); if (getValue() == m_falseItem.value()) setSelectedIndex(1);
else if (getValue() == false)
setSelectedIndex(1);
}
void ChangeValueDisplay<bool>::itemPressed(int index)
{
switch (index)
{
case 0: setValue(true); break;
case 1: setValue(false); break;
}
triggered();
} }
} }

89
src/changevaluedisplay_controlmode.h
View File

@ -4,7 +4,8 @@
#include "menudisplay.h" #include "menudisplay.h"
#include "staticmenudefinition.h" #include "staticmenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/dummyaction.h" #include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h" #include "icons/back.h"
#include "texts.h" #include "texts.h"
@ -12,13 +13,6 @@ namespace {
template<> template<>
class ChangeValueDisplay<ControlMode> : class ChangeValueDisplay<ControlMode> :
public MenuDisplay, public MenuDisplay,
public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_OPENMODE>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_VOLTAGE>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_SPEED>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_TORQUE>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, DummyAction, StaticMenuItemIcon<&icons::back>>
>,
public virtual AccessorInterface<ControlMode>, public virtual AccessorInterface<ControlMode>,
public virtual ActionInterface public virtual ActionInterface
{ {
@ -27,38 +21,71 @@ class ChangeValueDisplay<ControlMode> :
public: public:
void start() override; void start() override;
void itemPressed(int index) override; std::size_t size() const override { return 5; }
MenuItem& getMenuItem(std::size_t index) override
{
switch (index)
{
case 0: return m_openModeItem;
case 1: return m_voltageItem;
case 2: return m_speedItem;
case 3: return m_torqueItem;
case 4: return m_backItem;
}
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
switch (index)
{
case 0: return m_openModeItem;
case 1: return m_voltageItem;
case 2: return m_speedItem;
case 3: return m_torqueItem;
case 4: return m_backItem;
}
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{
callback(m_openModeItem);
callback(m_voltageItem);
callback(m_speedItem);
callback(m_torqueItem);
callback(m_backItem);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
{
callback(m_openModeItem);
callback(m_voltageItem);
callback(m_speedItem);
callback(m_torqueItem);
callback(m_backItem);
}
private:
makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_OPENMODE>> m_openModeItem{ControlMode::OpenMode, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_VOLTAGE>> m_voltageItem{ControlMode::Voltage, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_SPEED>> m_speedItem{ControlMode::Speed, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_TORQUE>> m_torqueItem{ControlMode::Torque, *this, *this};
makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem;
}; };
void ChangeValueDisplay<ControlMode>::start() void ChangeValueDisplay<ControlMode>::start()
{ {
Base::start(); Base::start();
if (getValue() == ControlMode::OpenMode) if (getValue() == m_openModeItem.value()) setSelectedIndex(0); else
setSelectedIndex(0); if (getValue() == m_voltageItem.value()) setSelectedIndex(1); else
else if (getValue() == ControlMode::Voltage) if (getValue() == m_speedItem.value()) setSelectedIndex(2); else
setSelectedIndex(1); if (getValue() == m_torqueItem.value()) setSelectedIndex(3); else
else if (getValue() == ControlMode::Speed)
setSelectedIndex(2);
else if (getValue() == ControlMode::Torque)
setSelectedIndex(3);
else
{ {
Serial.printf("Unknown ControlMode: %i", int(getValue())); Serial.printf("Unknown ControlMode: %i", int(getValue()));
setSelectedIndex(4); setSelectedIndex(4);
} }
} }
void ChangeValueDisplay<ControlMode>::itemPressed(int index)
{
switch (index)
{
case 0: setValue(ControlMode::OpenMode); break;
case 1: setValue(ControlMode::Voltage); break;
case 2: setValue(ControlMode::Speed); break;
case 3: setValue(ControlMode::Torque); break;
}
triggered();
}
} }

79
src/changevaluedisplay_controltype.h
View File

@ -4,7 +4,8 @@
#include "menudisplay.h" #include "menudisplay.h"
#include "staticmenudefinition.h" #include "staticmenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/dummyaction.h" #include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h" #include "icons/back.h"
#include "texts.h" #include "texts.h"
@ -12,12 +13,6 @@ namespace {
template<> template<>
class ChangeValueDisplay<ControlType> : class ChangeValueDisplay<ControlType> :
public MenuDisplay, public MenuDisplay,
public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_COMMUTATION>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_SINUSOIDAL>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_FIELDORIENTEDCONTROL>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, DummyAction, StaticMenuItemIcon<&icons::back>>
>,
public virtual AccessorInterface<ControlType>, public virtual AccessorInterface<ControlType>,
public virtual ActionInterface public virtual ActionInterface
{ {
@ -26,35 +21,65 @@ class ChangeValueDisplay<ControlType> :
public: public:
void start() override; void start() override;
void itemPressed(int index) override; std::size_t size() const override { return 4; }
MenuItem& getMenuItem(std::size_t index) override
{
switch (index)
{
case 0: return m_commutationItem;
case 1: return m_sinusoidalItem;
case 2: return m_fieldOrientedControlItem;
case 3: return m_backItem;
}
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
switch (index)
{
case 0: return m_commutationItem;
case 1: return m_sinusoidalItem;
case 2: return m_fieldOrientedControlItem;
case 3: return m_backItem;
}
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{
callback(m_commutationItem);
callback(m_sinusoidalItem);
callback(m_fieldOrientedControlItem);
callback(m_backItem);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
{
callback(m_commutationItem);
callback(m_sinusoidalItem);
callback(m_fieldOrientedControlItem);
callback(m_backItem);
}
private:
makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_COMMUTATION>> m_commutationItem{ControlType::Commutation, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_SINUSOIDAL>> m_sinusoidalItem{ControlType::Sinusoidal, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_FIELDORIENTEDCONTROL>> m_fieldOrientedControlItem{ControlType::FieldOrientedControl, *this, *this};
makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
}; };
void ChangeValueDisplay<ControlType>::start() void ChangeValueDisplay<ControlType>::start()
{ {
Base::start(); Base::start();
if (getValue() == ControlType::Commutation) if (getValue() == m_commutationItem.value()) setSelectedIndex(0); else
setSelectedIndex(0); if (getValue() == m_sinusoidalItem.value()) setSelectedIndex(1); else
else if (getValue() == ControlType::Sinusoidal) if (getValue() == m_fieldOrientedControlItem.value()) setSelectedIndex(2); else
setSelectedIndex(1);
else if (getValue() == ControlType::FieldOrientedControl)
setSelectedIndex(2);
else
{ {
Serial.printf("Unknown ControlType: %i", int(getValue())); Serial.printf("Unknown ControlType: %i", int(getValue()));
setSelectedIndex(3); setSelectedIndex(3);
} }
} }
void ChangeValueDisplay<ControlType>::itemPressed(int index)
{
switch (index)
{
case 0: setValue(ControlType::Commutation); break;
case 1: setValue(ControlType::Sinusoidal); break;
case 2: setValue(ControlType::FieldOrientedControl); break;
}
triggered();
}
} }

89
src/changevaluedisplay_larsmmode_mode.h
View File

@ -4,7 +4,8 @@
#include "menudisplay.h" #include "menudisplay.h"
#include "staticmenudefinition.h" #include "staticmenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/dummyaction.h" #include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h" #include "icons/back.h"
#include "texts.h" #include "texts.h"
#include "modes/larsmmode.h" #include "modes/larsmmode.h"
@ -13,13 +14,6 @@ namespace {
template<> template<>
class ChangeValueDisplay<LarsmModeMode> : class ChangeValueDisplay<LarsmModeMode> :
public MenuDisplay, public MenuDisplay,
public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_LARSMMODE1>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_LARSMMODE2>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_LARSMMODE3>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_LARSMMODE4>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, DummyAction, StaticMenuItemIcon<&icons::back>>
>,
public virtual AccessorInterface<LarsmModeMode>, public virtual AccessorInterface<LarsmModeMode>,
public virtual ActionInterface public virtual ActionInterface
{ {
@ -28,38 +22,71 @@ class ChangeValueDisplay<LarsmModeMode> :
public: public:
void start() override; void start() override;
void itemPressed(int index) override; std::size_t size() const override { return 5; }
MenuItem& getMenuItem(std::size_t index) override
{
switch (index)
{
case 0: return m_larsmMode1Item;
case 1: return m_larsmMode2Item;
case 2: return m_larsmMode3Item;
case 3: return m_larsmMode4Item;
case 4: return m_backItem;
}
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
switch (index)
{
case 0: return m_larsmMode1Item;
case 1: return m_larsmMode2Item;
case 2: return m_larsmMode3Item;
case 3: return m_larsmMode4Item;
case 4: return m_backItem;
}
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{
callback(m_larsmMode1Item);
callback(m_larsmMode2Item);
callback(m_larsmMode3Item);
callback(m_larsmMode4Item);
callback(m_backItem);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
{
callback(m_larsmMode1Item);
callback(m_larsmMode2Item);
callback(m_larsmMode3Item);
callback(m_larsmMode4Item);
callback(m_backItem);
}
private:
makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE1>> m_larsmMode1Item{LarsmModeMode::Mode1, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE2>> m_larsmMode2Item{LarsmModeMode::Mode2, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE3>> m_larsmMode3Item{LarsmModeMode::Mode3, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE4>> m_larsmMode4Item{LarsmModeMode::Mode4, *this, *this};
makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
}; };
void ChangeValueDisplay<LarsmModeMode>::start() void ChangeValueDisplay<LarsmModeMode>::start()
{ {
Base::start(); Base::start();
if (getValue() == LarsmModeMode::Mode1) if (getValue() == m_larsmMode1Item.value()) setSelectedIndex(0); else
setSelectedIndex(0); if (getValue() == m_larsmMode2Item.value()) setSelectedIndex(1); else
else if (getValue() == LarsmModeMode::Mode2) if (getValue() == m_larsmMode3Item.value()) setSelectedIndex(2); else
setSelectedIndex(1); if (getValue() == m_larsmMode4Item.value()) setSelectedIndex(3); else
else if (getValue() == LarsmModeMode::Mode3)
setSelectedIndex(2);
else if (getValue() == LarsmModeMode::Mode4)
setSelectedIndex(3);
else
{ {
Serial.printf("Unknown LarsmModeMode: %i", int(getValue())); Serial.printf("Unknown LarsmModeMode: %i", int(getValue()));
setSelectedIndex(4); setSelectedIndex(4);
} }
} }
void ChangeValueDisplay<LarsmModeMode>::itemPressed(int index)
{
switch (index)
{
case 0: setValue(LarsmModeMode::Mode1); break;
case 1: setValue(LarsmModeMode::Mode2); break;
case 2: setValue(LarsmModeMode::Mode3); break;
case 3: setValue(LarsmModeMode::Mode4); break;
}
triggered();
}
} }

99
src/changevaluedisplay_unifiedmodelmode.h
View File

@ -4,7 +4,8 @@
#include "menudisplay.h" #include "menudisplay.h"
#include "staticmenudefinition.h" #include "staticmenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/dummyaction.h" #include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h" #include "icons/back.h"
#include "texts.h" #include "texts.h"
#include "unifiedmodelmode.h" #include "unifiedmodelmode.h"
@ -13,14 +14,6 @@ namespace {
template<> template<>
class ChangeValueDisplay<UnifiedModelMode> : class ChangeValueDisplay<UnifiedModelMode> :
public MenuDisplay, 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 AccessorInterface<UnifiedModelMode>,
public virtual ActionInterface public virtual ActionInterface
{ {
@ -29,41 +22,77 @@ class ChangeValueDisplay<UnifiedModelMode> :
public: public:
void start() override; void start() override;
void itemPressed(int index) override; std::size_t size() const override { return 6; }
MenuItem& getMenuItem(std::size_t index) override
{
switch (index)
{
case 0: return m_commutationItem;
case 1: return m_sinusoidalItem;
case 2: return m_focVoltageItem;
case 3: return m_focSpeedItem;
case 4: return m_focTorqueItem;
case 5: return m_backItem;
}
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
switch (index)
{
case 0: return m_commutationItem;
case 1: return m_sinusoidalItem;
case 2: return m_focVoltageItem;
case 3: return m_focSpeedItem;
case 4: return m_focTorqueItem;
case 5: return m_backItem;
}
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{
callback(m_commutationItem);
callback(m_sinusoidalItem);
callback(m_focVoltageItem);
callback(m_focSpeedItem);
callback(m_focTorqueItem);
callback(m_backItem);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
{
callback(m_commutationItem);
callback(m_sinusoidalItem);
callback(m_focVoltageItem);
callback(m_focSpeedItem);
callback(m_focTorqueItem);
callback(m_backItem);
}
private:
makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_COMMUTATION>> m_commutationItem{UnifiedModelMode::Commutation, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_SINUSOIDAL>> m_sinusoidalItem{UnifiedModelMode::Sinusoidal, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCVOLTAGE>> m_focVoltageItem{UnifiedModelMode::FocVoltage, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCSPEED>> m_focSpeedItem{UnifiedModelMode::FocSpeed, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCTORQUE>> m_focTorqueItem{UnifiedModelMode::FocTorque, *this, *this};
makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
}; };
void ChangeValueDisplay<UnifiedModelMode>::start() void ChangeValueDisplay<UnifiedModelMode>::start()
{ {
Base::start(); Base::start();
if (getValue() == UnifiedModelMode::Commutation) if (getValue() == m_commutationItem.value()) setSelectedIndex(0); else
setSelectedIndex(0); if (getValue() == m_sinusoidalItem.value()) setSelectedIndex(1); else
else if (getValue() == UnifiedModelMode::Sinusoidal) if (getValue() == m_focVoltageItem.value()) setSelectedIndex(2); else
setSelectedIndex(1); if (getValue() == m_focSpeedItem.value()) setSelectedIndex(3); else
else if (getValue() == UnifiedModelMode::FocVoltage) if (getValue() == m_focTorqueItem.value()) setSelectedIndex(4); else
setSelectedIndex(2);
else if (getValue() == UnifiedModelMode::FocSpeed)
setSelectedIndex(3);
else if (getValue() == UnifiedModelMode::FocTorque)
setSelectedIndex(4);
else
{ {
Serial.printf("Unknown UnifiedModelMode: %i", int(getValue())); Serial.printf("Unknown UnifiedModelMode: %i", int(getValue()));
setSelectedIndex(5); 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();
}
} }

89
src/changevaluedisplay_wifi_mode_t.h
View File

@ -6,7 +6,8 @@
#include "menudisplay.h" #include "menudisplay.h"
#include "staticmenudefinition.h" #include "staticmenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/dummyaction.h" #include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h" #include "icons/back.h"
#include "texts.h" #include "texts.h"
@ -14,13 +15,6 @@ namespace {
template<> template<>
class ChangeValueDisplay<wifi_mode_t> : class ChangeValueDisplay<wifi_mode_t> :
public MenuDisplay, public MenuDisplay,
public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_WIFI_MODE_NULL>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_MODE_STA>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_MODE_AP>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_MODE_APSTA>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, DummyAction, StaticMenuItemIcon<&icons::back>>
>,
public virtual AccessorInterface<wifi_mode_t>, public virtual AccessorInterface<wifi_mode_t>,
public virtual ActionInterface public virtual ActionInterface
{ {
@ -29,38 +23,71 @@ class ChangeValueDisplay<wifi_mode_t> :
public: public:
void start() override; void start() override;
void itemPressed(int index) override; std::size_t size() const override { return 5; }
MenuItem& getMenuItem(std::size_t index) override
{
switch (index)
{
case 0: return m_nullItem;
case 1: return m_staItem;
case 2: return m_apItem;
case 3: return m_apStaItem;
case 4: return m_backItem;
}
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
switch (index)
{
case 0: return m_nullItem;
case 1: return m_staItem;
case 2: return m_apItem;
case 3: return m_apStaItem;
case 4: return m_backItem;
}
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{
callback(m_nullItem);
callback(m_staItem);
callback(m_apItem);
callback(m_apStaItem);
callback(m_backItem);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
{
callback(m_nullItem);
callback(m_staItem);
callback(m_apItem);
callback(m_apStaItem);
callback(m_backItem);
}
private:
makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_NULL>> m_nullItem{WIFI_MODE_NULL, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_STA>> m_staItem{WIFI_MODE_STA, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_AP>> m_apItem{WIFI_MODE_AP, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_APSTA>> m_apStaItem{WIFI_MODE_APSTA, *this, *this};
makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
}; };
void ChangeValueDisplay<wifi_mode_t>::start() void ChangeValueDisplay<wifi_mode_t>::start()
{ {
Base::start(); Base::start();
if (getValue() == WIFI_MODE_NULL) if (getValue() == m_nullItem.value()) setSelectedIndex(0); else
setSelectedIndex(0); if (getValue() == m_staItem.value()) setSelectedIndex(1); else
else if (getValue() == WIFI_MODE_STA) if (getValue() == m_apItem.value()) setSelectedIndex(2); else
setSelectedIndex(1); if (getValue() == m_apStaItem.value()) setSelectedIndex(3); else
else if (getValue() == WIFI_MODE_AP)
setSelectedIndex(2);
else if (getValue() == WIFI_MODE_APSTA)
setSelectedIndex(3);
else
{ {
Serial.printf("Unknown wifi_mode_t: %i", int(getValue())); Serial.printf("Unknown wifi_mode_t: %i", int(getValue()));
setSelectedIndex(4); setSelectedIndex(4);
} }
} }
void ChangeValueDisplay<wifi_mode_t>::itemPressed(int index)
{
switch (index)
{
case 0: setValue(WIFI_MODE_NULL); break;
case 1: setValue(WIFI_MODE_STA); break;
case 2: setValue(WIFI_MODE_AP); break;
case 3: setValue(WIFI_MODE_APSTA); break;
}
triggered();
}
} }

169
src/changevaluedisplay_wifi_power_t.h
View File

@ -6,7 +6,8 @@
#include "menudisplay.h" #include "menudisplay.h"
#include "staticmenudefinition.h" #include "staticmenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/dummyaction.h" #include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h" #include "icons/back.h"
#include "texts.h" #include "texts.h"
@ -14,21 +15,6 @@ namespace {
template<> template<>
class ChangeValueDisplay<wifi_power_t> : class ChangeValueDisplay<wifi_power_t> :
public MenuDisplay, public MenuDisplay,
public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_19_5dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_19dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_18_5dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_17dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_15dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_13dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_11dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_8_5dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_7dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_5dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_2dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_WIFI_POWER_MINUS_1dBm>, DummyAction>,
makeComponent<MenuItem, StaticText<TEXT_BACK>, DummyAction, StaticMenuItemIcon<&icons::back>>
>,
public virtual AccessorInterface<wifi_power_t>, public virtual AccessorInterface<wifi_power_t>,
public virtual ActionInterface public virtual ActionInterface
{ {
@ -37,62 +23,119 @@ class ChangeValueDisplay<wifi_power_t> :
public: public:
void start() override; void start() override;
void itemPressed(int index) override; std::size_t size() const override { return 13; }
MenuItem& getMenuItem(std::size_t index) override
{
switch (index)
{
case 0: return m_19_5dBmItem;
case 1: return m_19dBmItem;
case 2: return m_18_5dBmItem;
case 3: return m_17dBmItem;
case 4: return m_15dBmItem;
case 5: return m_13dBmItem;
case 6: return m_11dBmItem;
case 7: return m_8_5dBmItem;
case 8: return m_7dBmItem;
case 9: return m_5dBmItem;
case 10: return m_2dBmItem;
case 11: return m_MINUS_1dBmItem;
case 12: return m_backItem;
}
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
switch (index)
{
case 0: return m_19_5dBmItem;
case 1: return m_19dBmItem;
case 2: return m_18_5dBmItem;
case 3: return m_17dBmItem;
case 4: return m_15dBmItem;
case 5: return m_13dBmItem;
case 6: return m_11dBmItem;
case 7: return m_8_5dBmItem;
case 8: return m_7dBmItem;
case 9: return m_5dBmItem;
case 10: return m_2dBmItem;
case 11: return m_MINUS_1dBmItem;
case 12: return m_backItem;
}
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{
callback(m_19_5dBmItem);
callback(m_19dBmItem);
callback(m_18_5dBmItem);
callback(m_17dBmItem);
callback(m_15dBmItem);
callback(m_13dBmItem);
callback(m_11dBmItem);
callback(m_8_5dBmItem);
callback(m_7dBmItem);
callback(m_5dBmItem);
callback(m_2dBmItem);
callback(m_MINUS_1dBmItem);
callback(m_backItem);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
{
callback(m_19_5dBmItem);
callback(m_19dBmItem);
callback(m_18_5dBmItem);
callback(m_17dBmItem);
callback(m_15dBmItem);
callback(m_13dBmItem);
callback(m_11dBmItem);
callback(m_8_5dBmItem);
callback(m_7dBmItem);
callback(m_5dBmItem);
callback(m_2dBmItem);
callback(m_MINUS_1dBmItem);
callback(m_backItem);
}
private:
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_19_5dBm>> m_19_5dBmItem{WIFI_POWER_19_5dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_19dBm>> m_19dBmItem{WIFI_POWER_19dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_18_5dBm>> m_18_5dBmItem{WIFI_POWER_18_5dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_17dBm>> m_17dBmItem{WIFI_POWER_17dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_15dBm>> m_15dBmItem{WIFI_POWER_15dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_13dBm>> m_13dBmItem{WIFI_POWER_13dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_11dBm>> m_11dBmItem{WIFI_POWER_11dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_8_5dBm>> m_8_5dBmItem{WIFI_POWER_8_5dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_7dBm>> m_7dBmItem{WIFI_POWER_7dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_5dBm>> m_5dBmItem{WIFI_POWER_5dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_2dBm>> m_2dBmItem{WIFI_POWER_2dBm, *this, *this};
makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_MINUS_1dBm>> m_MINUS_1dBmItem{WIFI_POWER_MINUS_1dBm, *this, *this};
makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>> m_backItem{*this};
}; };
void ChangeValueDisplay<wifi_power_t>::start() void ChangeValueDisplay<wifi_power_t>::start()
{ {
Base::start(); Base::start();
if (getValue() == WIFI_POWER_19_5dBm) if (getValue() == m_19_5dBmItem.value()) setSelectedIndex(0); else
setSelectedIndex(0); if (getValue() == m_19dBmItem.value()) setSelectedIndex(1); else
else if (getValue() == WIFI_POWER_19dBm) if (getValue() == m_18_5dBmItem.value()) setSelectedIndex(2); else
setSelectedIndex(1); if (getValue() == m_17dBmItem.value()) setSelectedIndex(3); else
else if (getValue() == WIFI_POWER_18_5dBm) if (getValue() == m_15dBmItem.value()) setSelectedIndex(4); else
setSelectedIndex(2); if (getValue() == m_13dBmItem.value()) setSelectedIndex(5); else
else if (getValue() == WIFI_POWER_17dBm) if (getValue() == m_11dBmItem.value()) setSelectedIndex(6); else
setSelectedIndex(3); if (getValue() == m_8_5dBmItem.value()) setSelectedIndex(7); else
else if (getValue() == WIFI_POWER_15dBm) if (getValue() == m_7dBmItem.value()) setSelectedIndex(8); else
setSelectedIndex(4); if (getValue() == m_5dBmItem.value()) setSelectedIndex(9); else
else if (getValue() == WIFI_POWER_13dBm) if (getValue() == m_2dBmItem.value()) setSelectedIndex(10); else
setSelectedIndex(5); if (getValue() == m_MINUS_1dBmItem.value()) setSelectedIndex(11); else
else if (getValue() == WIFI_POWER_11dBm)
setSelectedIndex(6);
else if (getValue() == WIFI_POWER_8_5dBm)
setSelectedIndex(7);
else if (getValue() == WIFI_POWER_7dBm)
setSelectedIndex(8);
else if (getValue() == WIFI_POWER_5dBm)
setSelectedIndex(9);
else if (getValue() == WIFI_POWER_2dBm)
setSelectedIndex(10);
else if (getValue() == WIFI_POWER_MINUS_1dBm)
setSelectedIndex(11);
else
{ {
Serial.printf("Unknown wifi_power_t: %i", int(getValue())); Serial.printf("Unknown wifi_power_t: %i", int(getValue()));
setSelectedIndex(12); setSelectedIndex(12);
} }
} }
void ChangeValueDisplay<wifi_power_t>::itemPressed(int index)
{
switch (index)
{
case 0: setValue(WIFI_POWER_19_5dBm); break;
case 1: setValue(WIFI_POWER_19dBm); break;
case 2: setValue(WIFI_POWER_18_5dBm); break;
case 3: setValue(WIFI_POWER_17dBm); break;
case 4: setValue(WIFI_POWER_15dBm); break;
case 5: setValue(WIFI_POWER_13dBm); break;
case 6: setValue(WIFI_POWER_11dBm); break;
case 7: setValue(WIFI_POWER_8_5dBm); break;
case 8: setValue(WIFI_POWER_7dBm); break;
case 9: setValue(WIFI_POWER_5dBm); break;
case 10: setValue(WIFI_POWER_2dBm); break;
case 11: setValue(WIFI_POWER_MINUS_1dBm); break;
}
triggered();
}
} }

95
src/debugtexthelpers.h
View File

@ -16,37 +16,30 @@ struct ControllerTexts
struct PoweroffText : public virtual TextInterface { public: String text() const override { return String{"poweroff: "} + toString(controller::get().command.poweroff); } }; struct PoweroffText : public virtual TextInterface { public: String text() const override { return String{"poweroff: "} + toString(controller::get().command.poweroff); } };
struct LedText : public virtual TextInterface { public: String text() const override { return String{"led: "} + toString(controller::get().command.led); } }; struct LedText : public virtual TextInterface { public: String text() const override { return String{"led: "} + toString(controller::get().command.led); } };
struct LeftCommand private:
{ struct LeftCommandGetter { static const MotorState &get() { return controller::get().command.left; } };
LeftCommand() = delete; struct RightCommandGetter { static const MotorState &get() { return controller::get().command.right; } };
~LeftCommand() = delete;
struct EnableText : public virtual TextInterface { public: String text() const override { return String{"enable: "} + toString(controller::get().command.left.enable); } }; template<typename MotorStateGetter>
struct PwmText : public virtual TextInterface { public: String text() const override { return String{"pwm: "} + toString(controller::get().command.left.pwm); } }; struct CommandTexts
struct CtrlTypText : public virtual TextInterface { public: String text() const override { return String{"ctrlTyp: "} + toString(controller::get().command.left.ctrlTyp); } }; {
struct CtrlModText : public virtual TextInterface { public: String text() const override { return String{"ctrlMod: "} + toString(controller::get().command.left.ctrlMod); } }; CommandTexts() = delete;
struct IMotMaxText : public virtual TextInterface { public: String text() const override { return String{"iMotMax: "} + toString(controller::get().command.left.iMotMax); } }; ~CommandTexts() = delete;
struct IDcMaxText : public virtual TextInterface { public: String text() const override { return String{"iDcMax: "} + toString(controller::get().command.left.iDcMax); } };
struct NMotMaxText : public virtual TextInterface { public: String text() const override { return String{"nMotMax: "} + toString(controller::get().command.left.nMotMax); } }; struct EnableText : public virtual TextInterface { public: String text() const override { return String{"enable: "} + toString(MotorStateGetter::get().enable); } };
struct FieldWeakMaxText : public virtual TextInterface { public: String text() const override { return String{"fieldWeakMax: "} + toString(controller::get().command.left.fieldWeakMax); } }; struct PwmText : public virtual TextInterface { public: String text() const override { return String{"pwm: "} + toString(MotorStateGetter::get().pwm); } };
struct PhaseAdvMaxText : public virtual TextInterface { public: String text() const override { return String{"phaseAdvMax: "} + toString(controller::get().command.left.phaseAdvMax); } }; struct CtrlTypText : public virtual TextInterface { public: String text() const override { return String{"ctrlTyp: "} + toString(MotorStateGetter::get().ctrlTyp); } };
struct CtrlModText : public virtual TextInterface { public: String text() const override { return String{"ctrlMod: "} + toString(MotorStateGetter::get().ctrlMod); } };
struct IMotMaxText : public virtual TextInterface { public: String text() const override { return String{"iMotMax: "} + toString(MotorStateGetter::get().iMotMax); } };
struct IDcMaxText : public virtual TextInterface { public: String text() const override { return String{"iDcMax: "} + toString(MotorStateGetter::get().iDcMax); } };
struct NMotMaxText : public virtual TextInterface { public: String text() const override { return String{"nMotMax: "} + toString(MotorStateGetter::get().nMotMax); } };
struct FieldWeakMaxText : public virtual TextInterface { public: String text() const override { return String{"fieldWeakMax: "} + toString(MotorStateGetter::get().fieldWeakMax); } };
struct PhaseAdvMaxText : public virtual TextInterface { public: String text() const override { return String{"phaseAdvMax: "} + toString(MotorStateGetter::get().phaseAdvMax); } };
}; };
struct RightCommand public:
{ using LeftCommand = CommandTexts<LeftCommandGetter>;
RightCommand() = delete; using RightCommand = CommandTexts<LeftCommandGetter>;
~RightCommand() = delete;
struct EnableText : public virtual TextInterface { public: String text() const override { return String{"enable: "} + toString(controller::get().command.right.enable); } };
struct PwmText : public virtual TextInterface { public: String text() const override { return String{"pwm: "} + toString(controller::get().command.right.pwm); } };
struct CtrlTypText : public virtual TextInterface { public: String text() const override { return String{"ctrlTyp: "} + toString(controller::get().command.right.ctrlTyp); } };
struct CtrlModText : public virtual TextInterface { public: String text() const override { return String{"ctrlMod: "} + toString(controller::get().command.right.ctrlMod); } };
struct IMotMaxText : public virtual TextInterface { public: String text() const override { return String{"iMotMax: "} + toString(controller::get().command.right.iMotMax); } };
struct IDcMaxText : public virtual TextInterface { public: String text() const override { return String{"iDcMax: "} + toString(controller::get().command.right.iDcMax); } };
struct NMotMaxText : public virtual TextInterface { public: String text() const override { return String{"nMotMax: "} + toString(controller::get().command.right.nMotMax); } };
struct FieldWeakMaxText : public virtual TextInterface { public: String text() const override { return String{"fieldWeakMax: "} + toString(controller::get().command.right.fieldWeakMax); } };
struct PhaseAdvMaxText : public virtual TextInterface { public: String text() const override { return String{"phaseAdvMax: "} + toString(controller::get().command.right.phaseAdvMax); } };
};
struct BatVoltageText : public virtual TextInterface { public: String text() const override { auto line = String{"batVoltage: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.batVoltage); return line; } }; struct BatVoltageText : public virtual TextInterface { public: String text() const override { auto line = String{"batVoltage: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.batVoltage); return line; } };
struct BatVoltageFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"batVoltage: "}; if (controller::get().feedbackValid) line += toString(fixBatVoltage(controller::get().feedback.batVoltage)) + 'V'; return line; } }; struct BatVoltageFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"batVoltage: "}; if (controller::get().feedbackValid) line += toString(fixBatVoltage(controller::get().feedback.batVoltage)) + 'V'; return line; } };
@ -54,35 +47,29 @@ struct ControllerTexts
struct BoardTempFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"boardTemp: "}; if (controller::get().feedbackValid) line += toString(fixBoardTemp(controller::get().feedback.boardTemp)) + 'C'; return line; } }; struct BoardTempFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"boardTemp: "}; if (controller::get().feedbackValid) line += toString(fixBoardTemp(controller::get().feedback.boardTemp)) + 'C'; return line; } };
struct TimeoutCntSerialText : public virtual TextInterface { public: String text() const override { auto line = String{"timeoutCntSerial: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.timeoutCntSerial); return line; } }; struct TimeoutCntSerialText : public virtual TextInterface { public: String text() const override { auto line = String{"timeoutCntSerial: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.timeoutCntSerial); return line; } };
struct LeftFeedback private:
{ struct LeftFeedbackGetter { static const MotorFeedback &get() { return controller::get().feedback.left; } };
LeftFeedback() = delete; struct RightFeedbackGetter { static const MotorFeedback &get() { return controller::get().feedback.right; } };
~LeftFeedback() = delete;
struct AngleText : public virtual TextInterface { public: String text() const override { auto line = String{"angle: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.angle); return line; } }; template<typename MotorFeedbackGetter>
struct SpeedText : public virtual TextInterface { public: String text() const override { auto line = String{"speed: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.speed); return line; } }; struct FeedbackTexts
struct SpeedKmhText : public virtual TextInterface { public: String text() const override { auto line = String{"speed kmh: "}; if (controller::get().feedbackValid) line += toString(convertToKmh(controller::get().feedback.left.speed)); return line; } }; {
struct ErrorText : public virtual TextInterface { public: String text() const override { auto line = String{"error: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.error); return line; } }; FeedbackTexts() = delete;
struct CurrentText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.current); return line; } }; ~FeedbackTexts() = delete;
struct CurrentFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(fixCurrent(controller::get().feedback.left.current)) + 'A'; return line; } };
struct ChopsText : public virtual TextInterface { public: String text() const override { auto line = String{"chops: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.left.chops); return line; } }; struct AngleText : public virtual TextInterface { public: String text() const override { auto line = String{"angle: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().angle); return line; } };
struct HallText : public virtual TextInterface { public: String text() const override { auto line = String{"hall: "}; if (controller::get().feedbackValid) line += hallString(controller::get().feedback.left); return line; } }; struct SpeedText : public virtual TextInterface { public: String text() const override { auto line = String{"speed: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().speed); return line; } };
struct SpeedKmhText : public virtual TextInterface { public: String text() const override { auto line = String{"speed kmh: "}; if (controller::get().feedbackValid) line += toString(convertToKmh(MotorFeedbackGetter::get().speed)); return line; } };
struct ErrorText : public virtual TextInterface { public: String text() const override { auto line = String{"error: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().error); return line; } };
struct CurrentText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().current); return line; } };
struct CurrentFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(fixCurrent(MotorFeedbackGetter::get().current)) + 'A'; return line; } };
struct ChopsText : public virtual TextInterface { public: String text() const override { auto line = String{"chops: "}; if (controller::get().feedbackValid) line += toString(MotorFeedbackGetter::get().chops); return line; } };
struct HallText : public virtual TextInterface { public: String text() const override { auto line = String{"hall: "}; if (controller::get().feedbackValid) line += hallString(MotorFeedbackGetter::get()); return line; } };
}; };
struct RightFeedback public:
{ using LeftFeedback = FeedbackTexts<LeftFeedbackGetter>;
RightFeedback() = delete; using RightFeedback = FeedbackTexts<RightFeedbackGetter>;
~RightFeedback() = delete;
struct AngleText : public virtual TextInterface { public: String text() const override { auto line = String{"angle: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.angle); return line; } };
struct SpeedText : public virtual TextInterface { public: String text() const override { auto line = String{"speed: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.speed); return line; } };
struct SpeedKmhText : public virtual TextInterface { public: String text() const override { auto line = String{"speed kmh: "}; if (controller::get().feedbackValid) line += toString(convertToKmh(controller::get().feedback.right.speed)); return line; } };
struct ErrorText : public virtual TextInterface { public: String text() const override { auto line = String{"error: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.error); return line; } };
struct CurrentText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.current); return line; } };
struct CurrentFixedText : public virtual TextInterface { public: String text() const override { auto line = String{"current: "}; if (controller::get().feedbackValid) line += toString(fixCurrent(controller::get().feedback.right.current)) + 'A'; return line; } };
struct ChopsText : public virtual TextInterface { public: String text() const override { auto line = String{"chops: "}; if (controller::get().feedbackValid) line += toString(controller::get().feedback.right.chops); return line; } };
struct HallText : public virtual TextInterface { public: String text() const override { auto line = String{"hall: "}; if (controller::get().feedbackValid) line += hallString(controller::get().feedback.right); return line; } };
};
}; };
using FrontTexts = ControllerTexts<FrontControllerGetter>; using FrontTexts = ControllerTexts<FrontControllerGetter>;

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

@ -88,6 +88,8 @@ class DefaultModeSettingsMenu :
public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>, public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>,
public StaticMenuDefinition< public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<DefaultModeModelModeChangeDisplay>>, makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<DefaultModeModelModeChangeDisplay>>,
makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>, ToggleBoolAction, CheckboxIcon, DefaultModeSquareGasAccessor>,
makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>, ToggleBoolAction, CheckboxIcon, DefaultModeSquareBremsAccessor>,
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_SETSMOOTHING>, SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>,
makeComponent<MenuItem, StaticText<TEXT_SETFRONTPERCENTAGE>, SwitchScreenAction<DefaultModeFrontPercentageChangeDisplay>>, makeComponent<MenuItem, StaticText<TEXT_SETFRONTPERCENTAGE>, SwitchScreenAction<DefaultModeFrontPercentageChangeDisplay>>,

26
src/displays/menus/mainmenu.h
View File

@ -4,6 +4,7 @@
#include "staticmenudefinition.h" #include "staticmenudefinition.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
#include "actions/modesettingsaction.h"
#include "actions/rebootaction.h" #include "actions/rebootaction.h"
#include "texts.h" #include "texts.h"
#include "icons/back.h" #include "icons/back.h"
@ -37,22 +38,23 @@ class MainMenu :
public StaticText<TEXT_MAINMENU>, public StaticText<TEXT_MAINMENU>,
public BackActionInterface<SwitchScreenAction<StatusDisplay>>, public BackActionInterface<SwitchScreenAction<StatusDisplay>>,
public StaticMenuDefinition< public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_STATUS>, SwitchScreenAction<StatusDisplay>, StaticMenuItemIcon<&icons::back>>, makeComponent<MenuItem, StaticText<TEXT_STATUS>, SwitchScreenAction<StatusDisplay>, StaticMenuItemIcon<&icons::back>>,
makeComponent<MenuItem, StaticText<TEXT_SELECTMODE>, SwitchScreenAction<SelectModeMenu>, StaticMenuItemIcon<&icons::modes>>, makeComponent<MenuItem, StaticText<TEXT_SELECTMODE>, SwitchScreenAction<SelectModeMenu>, StaticMenuItemIcon<&icons::modes>>,
makeComponent<MenuItem, StaticText<TEXT_PRESETS>, SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&icons::presets>>, makeComponent<MenuItem, StaticText<TEXT_MODESETTINGS>, ModeSettingsAction>,
makeComponent<MenuItem, StaticText<TEXT_GRAPHS>, SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&icons::graph>>, makeComponent<MenuItem, StaticText<TEXT_PRESETS>, SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&icons::presets>>,
makeComponent<MenuItem, StaticText<TEXT_GRAPHS>, SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&icons::graph>>,
#ifdef FEATURE_BMS #ifdef FEATURE_BMS
makeComponent<MenuItem, StaticText<TEXT_BMS>, SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&icons::bms>>, makeComponent<MenuItem, StaticText<TEXT_BMS>, SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&icons::bms>>,
#endif #endif
makeComponent<MenuItem, StaticText<TEXT_SETTINGS>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::settings>>, makeComponent<MenuItem, StaticText<TEXT_SETTINGS>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::settings>>,
makeComponent<MenuItem, StaticText<TEXT_LOCKVEHICLE>, SwitchScreenAction<Lockscreen>, StaticMenuItemIcon<&icons::lock>>, makeComponent<MenuItem, StaticText<TEXT_LOCKVEHICLE>, SwitchScreenAction<Lockscreen>, StaticMenuItemIcon<&icons::lock>>,
#ifdef FEATURE_MOSFETS #ifdef FEATURE_MOSFETS
makeComponent<MenuItem, StaticText<TEXT_MOSFETS>, SwitchScreenAction<MosfetsMenu>, StaticMenuItemIcon<&icons::lock>>, // TODO icon makeComponent<MenuItem, StaticText<TEXT_MOSFETS>, SwitchScreenAction<MosfetsMenu>>,
#endif #endif
makeComponent<MenuItem, StaticText<TEXT_DEMOS>, SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&icons::demos>>, makeComponent<MenuItem, StaticText<TEXT_DEMOS>, SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&icons::demos>>,
makeComponent<MenuItem, StaticText<TEXT_POWEROFF>, SwitchScreenAction<PoweroffDisplay>, StaticMenuItemIcon<&icons::poweroff>>, makeComponent<MenuItem, StaticText<TEXT_POWEROFF>, SwitchScreenAction<PoweroffDisplay>, StaticMenuItemIcon<&icons::poweroff>>,
makeComponent<MenuItem, StaticText<TEXT_REBOOT>, RebootAction, StaticMenuItemIcon<&icons::reboot>>, makeComponent<MenuItem, StaticText<TEXT_REBOOT>, RebootAction, StaticMenuItemIcon<&icons::reboot>>,
makeComponent<MenuItem, StaticText<TEXT_DEBUG>, SwitchScreenAction<DebugMenu>> makeComponent<MenuItem, StaticText<TEXT_DEBUG>, SwitchScreenAction<DebugMenu>>
> >
{}; {};
}; };

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

@ -17,53 +17,59 @@ class MainMenu;
} }
namespace { namespace {
template<const Settings *preset>
class ApplyPresetAction : public virtual ActionInterface class ApplyPresetAction : public virtual ActionInterface
{ {
public: public:
void triggered() override { settings = *preset; saveSettings(); } void triggered() override { saveSettings(); switchScreen<MainMenu>(); }
};
template<const Settings *preset>
class ApplySettingsPresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings = *preset; ApplyPresetAction::triggered(); }
}; };
template<const Settings::Limits *preset> template<const Settings::Limits *preset>
class ApplyLimitsPresetAction : public virtual ActionInterface class ApplyLimitsPresetAction : public virtual ApplyPresetAction
{ {
public: public:
void triggered() override { settings.limits = *preset; saveSettings(); } void triggered() override { settings.limits = *preset; ApplyPresetAction::triggered(); }
}; };
template<const Settings::ControllerHardware *preset> template<const Settings::ControllerHardware *preset>
class ApplyControllerHardwarePresetAction : public virtual ActionInterface class ApplyControllerHardwarePresetAction : public virtual ApplyPresetAction
{ {
public: public:
void triggered() override { settings.controllerHardware = *preset; saveSettings(); } void triggered() override { settings.controllerHardware = *preset; ApplyPresetAction::triggered(); }
}; };
template<const Settings::BoardcomputerHardware *preset> template<const Settings::BoardcomputerHardware *preset>
class ApplyBoardcomputerHardwarePresetAction : public virtual ActionInterface class ApplyBoardcomputerHardwarePresetAction : public virtual ApplyPresetAction
{ {
public: public:
void triggered() override { settings.boardcomputerHardware = *preset; saveSettings(); } void triggered() override { settings.boardcomputerHardware = *preset; ApplyPresetAction::triggered(); }
}; };
template<const Settings::DefaultMode *preset> template<const Settings::DefaultMode *preset>
class ApplyDefaultModePresetAction : public virtual ActionInterface class ApplyDefaultModePresetAction : public virtual ApplyPresetAction
{ {
public: public:
void triggered() override { settings.defaultMode = *preset; saveSettings(); } void triggered() override { settings.defaultMode = *preset; ApplyPresetAction::triggered(); }
}; };
template<const Settings::TempomatMode *preset> template<const Settings::TempomatMode *preset>
class ApplyTempomatModePresetAction : public virtual ActionInterface class ApplyTempomatModePresetAction : public virtual ApplyPresetAction
{ {
public: public:
void triggered() override { settings.tempomatMode = *preset; saveSettings(); } void triggered() override { settings.tempomatMode = *preset; ApplyPresetAction::triggered(); }
}; };
template<const Settings::LarsmMode *preset> template<const Settings::LarsmMode *preset>
class ApplyLarsmModePresetAction : public virtual ActionInterface class ApplyLarsmModePresetAction : public virtual ApplyPresetAction
{ {
public: public:
void triggered() override { settings.larsmMode = *preset; saveSettings(); } void triggered() override { settings.larsmMode = *preset; ApplyPresetAction::triggered(); }
}; };
class PresetsMenu : class PresetsMenu :
@ -71,7 +77,7 @@ class PresetsMenu :
public StaticText<TEXT_PRESETS>, public StaticText<TEXT_PRESETS>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>,
public StaticMenuDefinition< public StaticMenuDefinition<
makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>, ApplyPresetAction<&presets::defaultSettings>>, makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>, ApplySettingsPresetAction<&presets::defaultSettings>>,
makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>, ApplyLimitsPresetAction<&presets::defaultLimits>>, makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>, ApplyLimitsPresetAction<&presets::defaultLimits>>,
makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>, ApplyLimitsPresetAction<&presets::kidsLimits>>, makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>, ApplyLimitsPresetAction<&presets::kidsLimits>>,
makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>, ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>>, makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>, ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>>,

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

@ -30,6 +30,24 @@ public:
void update() override; void update() override;
void stop() override; void stop() override;
std::size_t size() const override { return 1 + vec.size(); }
MenuItem& getMenuItem(std::size_t index) override
{
if (index == vec.size())
return m_backItem;
return vec[index];
}
const MenuItem& getMenuItem(std::size_t index) const override
{
if (index == vec.size())
return m_backItem;
return vec[index];
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{ {
for (auto &item : vec) for (auto &item : vec)

2
src/feedbackparser.h
View File

@ -24,7 +24,7 @@ public:
while (m_serial.get().available()) while (m_serial.get().available())
{ {
m_incomingByte = m_serial.get().read(); // Read the incoming byte m_incomingByte = m_serial.get().read(); // Read the incoming byte
m_bufStartFrame = ((uint16_t)(m_incomingBytePrev) << 8) + m_incomingByte; // Construct the start frame m_bufStartFrame = ((uint16_t)(m_incomingBytePrev) << 8) + m_incomingByte; // Construct the start frame
//Serial.printf("received: %x\r\n", m_incomingByte); //Serial.printf("received: %x\r\n", m_incomingByte);

13
src/globals.h
View File

@ -37,19 +37,14 @@ public:
std::array<Controller, 2>{{ std::array<Controller, 2>{{
Controller{Serial1, settings.controllerHardware.enableFrontLeft, settings.controllerHardware.enableFrontRight, settings.controllerHardware.invertFrontLeft, settings.controllerHardware.invertFrontRight}, Controller{Serial1, settings.controllerHardware.enableFrontLeft, settings.controllerHardware.enableFrontRight, settings.controllerHardware.invertFrontLeft, settings.controllerHardware.invertFrontRight},
Controller{Serial2, settings.controllerHardware.enableBackLeft, settings.controllerHardware.enableBackRight, settings.controllerHardware.invertBackLeft, settings.controllerHardware.invertBackRight} Controller{Serial2, settings.controllerHardware.enableBackLeft, settings.controllerHardware.enableBackRight, settings.controllerHardware.invertBackLeft, settings.controllerHardware.invertBackRight}
}}, }}
front{getFront()},
back(getBack())
{} {}
Controllers(const Controllers &) = delete; Controllers(const Controllers &) = delete;
Controllers &operator=(const Controllers &) = delete; Controllers &operator=(const Controllers &) = delete;
Controller &front; Controller &front{operator[](0)};
Controller &back; Controller &back{operator[](1)};
private:
Controller &getFront() { return operator[](0); }
Controller &getBack() { return operator[](1); }
}; };
Controllers controllers; Controllers controllers;

5
src/menudefinitioninterface.h
View File

@ -8,6 +8,11 @@ namespace {
class MenuDefinitionInterface class MenuDefinitionInterface
{ {
public: public:
virtual std::size_t size() const = 0;
virtual MenuItem& getMenuItem(std::size_t index) = 0;
virtual const MenuItem& getMenuItem(std::size_t index) const = 0;
virtual void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) = 0; virtual void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) = 0;
virtual void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const = 0; virtual void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const = 0;
}; };

20
src/menudisplay.h
View File

@ -24,8 +24,6 @@ public:
void rotate(int offset) override; void rotate(int offset) override;
void confirm() override; void confirm() override;
virtual void itemPressed(int index);
TextInterface *asTextInterface() override { return this; } TextInterface *asTextInterface() override { return this; }
const TextInterface *asTextInterface() const override { return this; } const TextInterface *asTextInterface() const override { return this; }
@ -104,11 +102,7 @@ void MenuDisplay::update()
const auto offset = m_rotateOffset; const auto offset = m_rotateOffset;
m_rotateOffset = 0; m_rotateOffset = 0;
const auto itemCount = [&](){ const auto itemCount = size();
int i{0};
runForEveryMenuItem([&](MenuItem&){ i++; });
return i;
}();
if (itemCount) if (itemCount)
{ {
@ -141,7 +135,7 @@ void MenuDisplay::update()
{ {
m_pressed = false; m_pressed = false;
if (m_selectedIndex >= 0) if (m_selectedIndex >= 0)
itemPressed(m_selectedIndex); getMenuItem(m_selectedIndex).triggered();
} }
} }
@ -246,14 +240,4 @@ void MenuDisplay::confirm()
{ {
m_pressed = true; m_pressed = true;
} }
void MenuDisplay::itemPressed(int index)
{
int i{0};
runForEveryMenuItem([&](MenuItem &item){
if (i++ == index)
item.triggered();
});
}
} }

11
src/modes/defaultmode.h
View File

@ -38,7 +38,6 @@ void DefaultMode::update()
else else
gas = 0; gas = 0;
} }
const auto gas_squared = (gas * gas) / 1000;
if (waitForBremsLoslass) if (waitForBremsLoslass)
{ {
@ -47,14 +46,16 @@ void DefaultMode::update()
else else
brems = 0; brems = 0;
} }
const auto brems_squared = (brems * brems) / 1000;
const auto gas_processed = settings.defaultMode.squareGas ? (gas * gas) / 1000.f : gas;
const auto brems_processed = settings.defaultMode.squareBrems ? (brems * brems) / 1000 : brems;
const auto now = millis(); const auto now = millis();
float pwm; float pwm;
if (gas_squared >= settings.defaultMode.add_schwelle) if (gas_processed >= settings.defaultMode.add_schwelle)
{ {
pwm = (gas_squared/1000.*settings.defaultMode.gas1_wert) + (brems_squared/1000.*settings.defaultMode.brems1_wert); pwm = (gas_processed/1000.*settings.defaultMode.gas1_wert) + (brems_processed/1000.*settings.defaultMode.brems1_wert);
if (settings.defaultMode.enableSmoothing && (pwm > 1000. || lastPwm > 1000.)) if (settings.defaultMode.enableSmoothing && (pwm > 1000. || lastPwm > 1000.))
{ {
@ -71,7 +72,7 @@ void DefaultMode::update()
} }
} }
else else
pwm = (gas_squared/1000.*settings.defaultMode.gas2_wert) - (brems_squared/1000.*settings.defaultMode.brems2_wert); pwm = (gas_processed/1000.*settings.defaultMode.gas2_wert) - (brems_processed/1000.*settings.defaultMode.brems2_wert);
lastPwm = pwm; lastPwm = pwm;
lastTime = now; lastTime = now;

4
src/presets.h
View File

@ -107,6 +107,8 @@ constexpr Settings::BoardcomputerHardware defaultBoardcomputerHardware {
constexpr Settings::DefaultMode defaultDefaultMode { constexpr Settings::DefaultMode defaultDefaultMode {
.modelMode = UnifiedModelMode::FocTorque, .modelMode = UnifiedModelMode::FocTorque,
.squareGas = true,
.squareBrems = true,
.enableSmoothing = true, .enableSmoothing = true,
.smoothing = 20, .smoothing = 20,
.frontPercentage = 100, .frontPercentage = 100,
@ -120,6 +122,8 @@ constexpr Settings::DefaultMode defaultDefaultMode {
constexpr Settings::DefaultMode sinusoidalDefaultMode { constexpr Settings::DefaultMode sinusoidalDefaultMode {
.modelMode = UnifiedModelMode::Sinusoidal, .modelMode = UnifiedModelMode::Sinusoidal,
.squareGas = true,
.squareBrems = true,
.enableSmoothing = true, .enableSmoothing = true,
.smoothing = 20, .smoothing = 20,
.frontPercentage = 100, .frontPercentage = 100,

2
src/settings.h
View File

@ -72,6 +72,8 @@ struct Settings
struct DefaultMode { struct DefaultMode {
UnifiedModelMode modelMode; UnifiedModelMode modelMode;
bool squareGas;
bool squareBrems;
bool enableSmoothing; bool enableSmoothing;
int16_t smoothing; int16_t smoothing;
int16_t frontPercentage; int16_t frontPercentage;

2
src/settingsaccessors.h
View File

@ -83,6 +83,8 @@ struct DisplayUpdateRateAccessor : public RefAccessorSaveSettings<int16_t> { int
struct DisplayRedrawRateAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.boardcomputerHardware.timersSettings.displayRedrawRate; } }; struct DisplayRedrawRateAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.boardcomputerHardware.timersSettings.displayRedrawRate; } };
struct DefaultModeModelModeAccessor : public RefAccessorSaveSettings<UnifiedModelMode> { UnifiedModelMode &getRef() const override { return settings.defaultMode.modelMode; } }; struct DefaultModeModelModeAccessor : public RefAccessorSaveSettings<UnifiedModelMode> { UnifiedModelMode &getRef() const override { return settings.defaultMode.modelMode; } };
struct DefaultModeSquareGasAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.defaultMode.squareGas; } };
struct DefaultModeSquareBremsAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.defaultMode.squareBrems; } };
struct DefaultModeEnableSmoothingAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.defaultMode.enableSmoothing; } }; 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 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; } }; struct DefaultModeFrontPercentageAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.defaultMode.frontPercentage; } };

36
src/staticmenudefinition.h
View File

@ -10,6 +10,24 @@ template<typename T>
class StaticMenuDefinition<T> : public virtual MenuDefinitionInterface class StaticMenuDefinition<T> : public virtual MenuDefinitionInterface
{ {
public: public:
std::size_t size() const override { return 1; }
MenuItem& getMenuItem(std::size_t index) override
{
if (index == 0)
return item;
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
if (index == 0)
return item;
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{ {
callback(item); callback(item);
@ -30,6 +48,24 @@ class StaticMenuDefinition<T, Tmore...> : public virtual StaticMenuDefinition<Tm
using Base = StaticMenuDefinition<Tmore...>; using Base = StaticMenuDefinition<Tmore...>;
public: public:
std::size_t size() const override { return 1 + sizeof...(Tmore); }
MenuItem& getMenuItem(std::size_t index) override
{
if (index == 0)
return item;
return Base::getMenuItem(index - 1);
}
const MenuItem& getMenuItem(std::size_t index) const override
{
if (index == 0)
return item;
return Base::getMenuItem(index - 1);
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{ {
callback(item); callback(item);

3
src/texts.h
View File

@ -54,6 +54,7 @@ constexpr char TEXT_BACKRIGHTFEEDBACK[] = "Back right feedback";
constexpr char TEXT_MAINMENU[] = "Main menu"; constexpr char TEXT_MAINMENU[] = "Main menu";
constexpr char TEXT_STATUS[] = "Status"; constexpr char TEXT_STATUS[] = "Status";
constexpr char TEXT_SELECTMODE[] = "Select mode"; constexpr char TEXT_SELECTMODE[] = "Select mode";
constexpr char TEXT_MODESETTINGS[] = "Mode settings";
constexpr char TEXT_PRESETS[] = "Presets"; constexpr char TEXT_PRESETS[] = "Presets";
constexpr char TEXT_GRAPHS[] = "Graphs"; constexpr char TEXT_GRAPHS[] = "Graphs";
//constexpr char TEXT_BMS[] = "BMS"; //constexpr char TEXT_BMS[] = "BMS";
@ -140,6 +141,8 @@ constexpr char TEXT_DYNAMICMENU[] = "Dynamic menu";
//DefaultModeSettingsMenu //DefaultModeSettingsMenu
//constexpr char TEXT_DEFAULTMODESETTINGS[] = "Default mode settings"; //constexpr char TEXT_DEFAULTMODESETTINGS[] = "Default mode settings";
constexpr char TEXT_SETMODELMODE[] = "Set model mode"; constexpr char TEXT_SETMODELMODE[] = "Set model mode";
constexpr char TEXT_SQUAREGAS[] = "Square gas";
constexpr char TEXT_SQUAREBREMS[] = "Square brems";
constexpr char TEXT_ENABLESMOOTHING[] = "Enable smoothing"; constexpr char TEXT_ENABLESMOOTHING[] = "Enable smoothing";
constexpr char TEXT_SETSMOOTHING[] = "Set smoothing"; constexpr char TEXT_SETSMOOTHING[] = "Set smoothing";
constexpr char TEXT_SETFRONTPERCENTAGE[] = "Set front percentage"; constexpr char TEXT_SETFRONTPERCENTAGE[] = "Set front percentage";

12
src/utils.h
View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <algorithm> #include <algorithm>
#include <utility>
#include <ArduinoOTA.h> #include <ArduinoOTA.h>
#include <WString.h> #include <WString.h>
@ -22,6 +23,17 @@ template<typename ...T>
class makeComponent : public T... class makeComponent : public T...
{}; {};
template <typename T1, typename T2, typename ...T3>
class makeComponentArgs : public T1, public T2, public T3...
{
public:
template<typename ...T>
makeComponentArgs(T&& ...args) :
T2{std::forward<T>(args)...}
{
}
};
template<typename T> template<typename T>
T scaleBetween(T x, T in_min, T in_max, T out_min, T out_max) { T scaleBetween(T x, T in_min, T in_max, T out_min, T out_max) {
if (x < std::min(in_min, in_max)) if (x < std::min(in_min, in_max))