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

Refactored code to shrink program size

Browse Source
This commit is contained in:
0xFEEDC0DE64
2020-06-28 04:28:54 +02:00
parent 470eea0dbe
commit d21d36585a
12 changed files with 559 additions and 277 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;
};
}

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

79
src/changevaluedisplay_bluetoothmode.h
View File

@ -4,7 +4,8 @@
#include "menudisplay.h"
#include "staticmenudefinition.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
#include "texts.h"
#include "bluetoothmode.h"
@ -13,12 +14,6 @@ namespace {
template<>
class ChangeValueDisplay<BluetoothMode> :
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 ActionInterface
{
@ -27,35 +22,65 @@ class ChangeValueDisplay<BluetoothMode> :
public:
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()
{
Base::start();
if (getValue() == BluetoothMode::Off)
setSelectedIndex(0);
else if (getValue() == BluetoothMode::Master)
setSelectedIndex(1);
else if (getValue() == BluetoothMode::Slave)
setSelectedIndex(2);
else
if (getValue() == m_offAction.value()) setSelectedIndex(0); else
if (getValue() == m_masterAction.value()) setSelectedIndex(1); else
if (getValue() == m_slaveAction.value()) setSelectedIndex(2); else
{
Serial.printf("Unknown BluetoothMode: %i", int(getValue()));
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 "actioninterface.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
#include "texts.h"
@ -13,11 +14,6 @@ namespace {
template<>
class ChangeValueDisplay<bool> :
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 ActionInterface
{
@ -26,27 +22,55 @@ class ChangeValueDisplay<bool> :
public:
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()
{
Base::start();
if (getValue() == true)
setSelectedIndex(0);
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();
if (getValue() == m_trueItem.value()) setSelectedIndex(0); else
if (getValue() == m_falseItem.value()) setSelectedIndex(1);
}
}

89
src/changevaluedisplay_controlmode.h
View File

@ -4,7 +4,8 @@
#include "menudisplay.h"
#include "staticmenudefinition.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
#include "texts.h"
@ -12,13 +13,6 @@ namespace {
template<>
class ChangeValueDisplay<ControlMode> :
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 ActionInterface
{
@ -27,38 +21,71 @@ class ChangeValueDisplay<ControlMode> :
public:
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()
{
Base::start();
if (getValue() == ControlMode::OpenMode)
setSelectedIndex(0);
else if (getValue() == ControlMode::Voltage)
setSelectedIndex(1);
else if (getValue() == ControlMode::Speed)
setSelectedIndex(2);
else if (getValue() == ControlMode::Torque)
setSelectedIndex(3);
else
if (getValue() == m_openModeItem.value()) setSelectedIndex(0); else
if (getValue() == m_voltageItem.value()) setSelectedIndex(1); else
if (getValue() == m_speedItem.value()) setSelectedIndex(2); else
if (getValue() == m_torqueItem.value()) setSelectedIndex(3); else
{
Serial.printf("Unknown ControlMode: %i", int(getValue()));
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 "staticmenudefinition.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
#include "texts.h"
@ -12,12 +13,6 @@ namespace {
template<>
class ChangeValueDisplay<ControlType> :
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 ActionInterface
{
@ -26,35 +21,65 @@ class ChangeValueDisplay<ControlType> :
public:
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()
{
Base::start();
if (getValue() == ControlType::Commutation)
setSelectedIndex(0);
else if (getValue() == ControlType::Sinusoidal)
setSelectedIndex(1);
else if (getValue() == ControlType::FieldOrientedControl)
setSelectedIndex(2);
else
if (getValue() == m_commutationItem.value()) setSelectedIndex(0); else
if (getValue() == m_sinusoidalItem.value()) setSelectedIndex(1); else
if (getValue() == m_fieldOrientedControlItem.value()) setSelectedIndex(2); else
{
Serial.printf("Unknown ControlType: %i", int(getValue()));
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 "staticmenudefinition.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
#include "texts.h"
#include "modes/larsmmode.h"
@ -13,13 +14,6 @@ namespace {
template<>
class ChangeValueDisplay<LarsmModeMode> :
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 ActionInterface
{
@ -28,38 +22,71 @@ class ChangeValueDisplay<LarsmModeMode> :
public:
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()
{
Base::start();
if (getValue() == LarsmModeMode::Mode1)
setSelectedIndex(0);
else if (getValue() == LarsmModeMode::Mode2)
setSelectedIndex(1);
else if (getValue() == LarsmModeMode::Mode3)
setSelectedIndex(2);
else if (getValue() == LarsmModeMode::Mode4)
setSelectedIndex(3);
else
if (getValue() == m_larsmMode1Item.value()) setSelectedIndex(0); else
if (getValue() == m_larsmMode2Item.value()) setSelectedIndex(1); else
if (getValue() == m_larsmMode3Item.value()) setSelectedIndex(2); else
if (getValue() == m_larsmMode4Item.value()) setSelectedIndex(3); else
{
Serial.printf("Unknown LarsmModeMode: %i", int(getValue()));
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 "staticmenudefinition.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
#include "texts.h"
#include "unifiedmodelmode.h"
@ -13,14 +14,6 @@ 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
{
@ -29,41 +22,77 @@ class ChangeValueDisplay<UnifiedModelMode> :
public:
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()
{
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
if (getValue() == m_commutationItem.value()) setSelectedIndex(0); else
if (getValue() == m_sinusoidalItem.value()) setSelectedIndex(1); else
if (getValue() == m_focVoltageItem.value()) setSelectedIndex(2); else
if (getValue() == m_focSpeedItem.value()) setSelectedIndex(3); else
if (getValue() == m_focTorqueItem.value()) 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();
}
}

89
src/changevaluedisplay_wifi_mode_t.h
View File

@ -6,7 +6,8 @@
#include "menudisplay.h"
#include "staticmenudefinition.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
#include "texts.h"
@ -14,13 +15,6 @@ namespace {
template<>
class ChangeValueDisplay<wifi_mode_t> :
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 ActionInterface
{
@ -29,38 +23,71 @@ class ChangeValueDisplay<wifi_mode_t> :
public:
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()
{
Base::start();
if (getValue() == WIFI_MODE_NULL)
setSelectedIndex(0);
else if (getValue() == WIFI_MODE_STA)
setSelectedIndex(1);
else if (getValue() == WIFI_MODE_AP)
setSelectedIndex(2);
else if (getValue() == WIFI_MODE_APSTA)
setSelectedIndex(3);
else
if (getValue() == m_nullItem.value()) setSelectedIndex(0); else
if (getValue() == m_staItem.value()) setSelectedIndex(1); else
if (getValue() == m_apItem.value()) setSelectedIndex(2); else
if (getValue() == m_apStaItem.value()) setSelectedIndex(3); else
{
Serial.printf("Unknown wifi_mode_t: %i", int(getValue()));
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 "staticmenudefinition.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
#include "texts.h"
@ -14,21 +15,6 @@ namespace {
template<>
class ChangeValueDisplay<wifi_power_t> :
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 ActionInterface
{
@ -37,62 +23,119 @@ class ChangeValueDisplay<wifi_power_t> :
public:
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()
{
Base::start();
if (getValue() == WIFI_POWER_19_5dBm)
setSelectedIndex(0);
else if (getValue() == WIFI_POWER_19dBm)
setSelectedIndex(1);
else if (getValue() == WIFI_POWER_18_5dBm)
setSelectedIndex(2);
else if (getValue() == WIFI_POWER_17dBm)
setSelectedIndex(3);
else if (getValue() == WIFI_POWER_15dBm)
setSelectedIndex(4);
else if (getValue() == WIFI_POWER_13dBm)
setSelectedIndex(5);
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
if (getValue() == m_19_5dBmItem.value()) setSelectedIndex(0); else
if (getValue() == m_19dBmItem.value()) setSelectedIndex(1); else
if (getValue() == m_18_5dBmItem.value()) setSelectedIndex(2); else
if (getValue() == m_17dBmItem.value()) setSelectedIndex(3); else
if (getValue() == m_15dBmItem.value()) setSelectedIndex(4); else
if (getValue() == m_13dBmItem.value()) setSelectedIndex(5); else
if (getValue() == m_11dBmItem.value()) setSelectedIndex(6); else
if (getValue() == m_8_5dBmItem.value()) setSelectedIndex(7); else
if (getValue() == m_7dBmItem.value()) setSelectedIndex(8); else
if (getValue() == m_5dBmItem.value()) setSelectedIndex(9); else
if (getValue() == m_2dBmItem.value()) setSelectedIndex(10); else
if (getValue() == m_MINUS_1dBmItem.value()) setSelectedIndex(11); else
{
Serial.printf("Unknown wifi_power_t: %i", int(getValue()));
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();
}
}

11
src/menudisplay.h
View File

@ -24,8 +24,6 @@ public:
void rotate(int offset) override;
void confirm() override;
virtual void itemPressed(int index);
TextInterface *asTextInterface() override { return this; }
const TextInterface *asTextInterface() const override { return this; }
@ -137,7 +135,7 @@ void MenuDisplay::update()
{
m_pressed = false;
if (m_selectedIndex >= 0)
itemPressed(m_selectedIndex);
getMenuItem(m_selectedIndex).triggered();
}
}
@ -242,11 +240,4 @@ void MenuDisplay::confirm()
{
m_pressed = true;
}
void MenuDisplay::itemPressed(int index)
{
int i{0};
getMenuItem(index).triggered();
}
}

12
src/utils.h
View File

@ -1,6 +1,7 @@
#pragma once
#include <algorithm>
#include <utility>
#include <ArduinoOTA.h>
#include <WString.h>
@ -22,6 +23,17 @@ template<typename ...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>
T scaleBetween(T x, T in_min, T in_max, T out_min, T out_max) {
if (x < std::min(in_min, in_max))