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

More program space savings by removing menu item interface abstraction

Browse Source
This commit is contained in:
0xFEEDC0DE64
2021-01-03 03:44:15 +01:00
parent 5ae0e6314e
commit b87a3c5fbc
53 changed files with 773 additions and 1065 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
platformio.ini
View File

@@ -8,6 +8,9 @@
; Please visit documentation for the other options and examples ; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html ; https://docs.platformio.org/page/projectconf.html
[platformio]
inc_dir = src/espcpputils
[common_env_data] [common_env_data]
platform = espressif32 platform = espressif32
board = esp32dev board = esp32dev
@@ -96,7 +99,7 @@ platform = ${common_env_data.platform}
board = ${common_env_data.board} board = ${common_env_data.board}
framework = ${common_env_data.framework} framework = ${common_env_data.framework}
platform_packages = ${common_env_data.platform_packages} platform_packages = ${common_env_data.platform_packages}
board_build.partitions = partitions_4M_noota.csv board_build.partitions = partitions_4M_ota.csv
lib_deps = lib_deps =
${common_env_data.lib_deps} ${common_env_data.lib_deps}
${webserver_common.lib_deps} ${webserver_common.lib_deps}
@@ -130,7 +133,8 @@ build_flags =
-DDEVICE_PREFIX=bobbyquad -DDEVICE_PREFIX=bobbyquad
-DAP_PASSWORD=Passwort_123 -DAP_PASSWORD=Passwort_123
${webserver_common.build_flags} ${webserver_common.build_flags}
; -DFEATURE_OTA -DFEATURE_ARDUINOOTA
; -DFEATURE_WEBOTA
-DFEATURE_DPAD_5WIRESW -DFEATURE_DPAD_5WIRESW
-DPINS_DPAD_5WIRESW_OUT=32 -DPINS_DPAD_5WIRESW_OUT=32
-DPINS_DPAD_5WIRESW_IN1=25 -DPINS_DPAD_5WIRESW_IN1=25
@@ -150,8 +154,8 @@ build_flags =
-DDEFAULT_GASMAX=3700 -DDEFAULT_GASMAX=3700
-DDEFAULT_BREMSMIN=1300 -DDEFAULT_BREMSMIN=1300
-DDEFAULT_BREMSMAX=4000 -DDEFAULT_BREMSMAX=4000
-DFEATURE_BLUETOOTH ; -DFEATURE_BLUETOOTH
-DFEATURE_BMS ; -DFEATURE_BMS
; -DFEATURE_GAMETRAK ; -DFEATURE_GAMETRAK
; -DPINS_GAMETRAKX=34 ; -DPINS_GAMETRAKX=34
; -DPINS_GAMETRAKY=39 ; -DPINS_GAMETRAKY=39
@@ -212,7 +216,7 @@ build_flags =
-DDEVICE_PREFIX=bobbycar -DDEVICE_PREFIX=bobbycar
-DAP_PASSWORD=Passwort_123 -DAP_PASSWORD=Passwort_123
${webserver_common.build_flags} ${webserver_common.build_flags}
-DFEATURE_OTA -DFEATURE_ARDUINOOTA
-DDEFAULT_GASMIN=400 -DDEFAULT_GASMIN=400
-DDEFAULT_GASMAX=2000 -DDEFAULT_GASMAX=2000
-DDEFAULT_BREMSMIN=600 -DDEFAULT_BREMSMIN=600
@@ -276,7 +280,7 @@ build_flags =
-DDEVICE_PREFIX=bobbyquad -DDEVICE_PREFIX=bobbyquad
-DAP_PASSWORD=Passwort_123 -DAP_PASSWORD=Passwort_123
${webserver_common.build_flags} ${webserver_common.build_flags}
-DFEATURE_OTA -DFEATURE_ARDUINOOTA
-DFEATURE_DPAD -DFEATURE_DPAD
-DPINS_DPAD_UP=32 -DPINS_DPAD_UP=32
-DPINS_DPAD_DOWN=22 -DPINS_DPAD_DOWN=22
@@ -310,7 +314,7 @@ build_flags =
-DDEVICE_PREFIX=bobbyquad -DDEVICE_PREFIX=bobbyquad
-DAP_PASSWORD=Passwort_123 -DAP_PASSWORD=Passwort_123
${webserver_common.build_flags} ${webserver_common.build_flags}
-DFEATURE_OTA -DFEATURE_ARDUINOOTA
-DRPI_DISPLAY_TYPE -DRPI_DISPLAY_TYPE
-DR61581_DRIVER -DR61581_DRIVER
; TODO: TFT_MISO (touch MISO?) ; TODO: TFT_MISO (touch MISO?)
@@ -359,7 +363,7 @@ build_flags =
-DDEVICE_PREFIX=bobbycar -DDEVICE_PREFIX=bobbycar
-DAP_PASSWORD=Passwort_123 -DAP_PASSWORD=Passwort_123
${webserver_common.build_flags} ${webserver_common.build_flags}
-DFEATURE_OTA -DFEATURE_ARDUINOOTA
-DDEFAULT_GASMIN=1000 -DDEFAULT_GASMIN=1000
-DDEFAULT_GASMAX=4000 -DDEFAULT_GASMAX=4000
-DDEFAULT_BREMSMIN=200 -DDEFAULT_BREMSMIN=200

108
src/bobby_webserver.h
View File

@@ -8,11 +8,15 @@
#include "textinterface.h" #include "textinterface.h"
#include "menudisplay.h" #include "menudisplay.h"
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "displays/updatedisplay.h"
//#include "esputils.h"
namespace { namespace {
#ifdef FEATURE_WEBSERVER #ifdef FEATURE_WEBSERVER
AsyncWebServer webServer{80}; AsyncWebServer webServer{80};
bool shouldReboot;
class HtmlTag { class HtmlTag {
public: public:
HtmlTag(const char *tagName, AsyncResponseStream *response) : HtmlTag(const char *tagName, AsyncResponseStream *response) :
@@ -34,6 +38,8 @@ private:
void initWebserver() void initWebserver()
{ {
shouldReboot = false;
DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin", "*"); DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin", "*");
webServer.on("/", HTTP_GET, [](AsyncWebServerRequest *request){ webServer.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
@@ -184,7 +190,7 @@ void initWebserver()
return; return;
} }
if (index < 0 || index >= menuDisplay->size()) if (index < 0 || index >= menuDisplay->menuItemCount())
{ {
request->send(400, "text/plain", "index out of range"); request->send(400, "text/plain", "index out of range");
return; return;
@@ -235,11 +241,111 @@ void initWebserver()
request->send(response); request->send(response);
}); });
#ifdef FEATURE_WEBOTA
webServer.on("/update", HTTP_GET, [](AsyncWebServerRequest *request){
request->send(200, "text/html",
"<form method=\"POST\" action=\"/updateCode\" enctype=\"multipart/form-data\">"
"<input type=\"file\" name=\"update\">"
"<input type=\"submit\" value=\"Update Code\">"
"</form>"
"<form method=\"POST\" action=\"/updateData\" enctype=\"multipart/form-data\">"
"<input type=\"file\" name=\"update\">"
"<input type=\"submit\" value=\"Update Data\">"
"</form>");
});
const auto handleUpdate = [](AsyncWebServerRequest *request){
shouldReboot = !Update.hasError();
AsyncWebServerResponse *response = request->beginResponse(200, "text/plain", shouldReboot ? "OK" : "FAIL");
response->addHeader("Connection", "close");
request->send(response);
};
const auto createHandleUpdtateUpload = [](size_t size, int command){
return [size, command](AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final){
//ESP_UNUSED(request)
Serial.printf("callback %u %u\r\n", index, len);
if (!index)
{
Serial.printf("Update Start: %s\r\n", filename.c_str());
//Update.runAsync(true);
if (!Update.begin(size, command))
Update.printError(Serial);
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else if (ArduinoOTA.getCommand() == U_SPIFFS) // U_SPIFFS
type = "filesystem";
else
type = "unknown";
switchScreenImpl<UpdateDisplay>("Updating " + type);
}
if (!Update.hasError())
{
if (Update.write(data, len) == len)
{
((UpdateDisplay*)currentDisplay.get())->m_progress = index;
((UpdateDisplay*)currentDisplay.get())->m_total = size;
((UpdateDisplay*)currentDisplay.get())->redraw();
}
else
{
Update.printError(Serial);
((UpdateDisplay*)currentDisplay.get())->m_error = {};
((UpdateDisplay*)currentDisplay.get())->m_errorValid = true;
((UpdateDisplay*)currentDisplay.get())->redraw();
}
}
else
{
((UpdateDisplay*)currentDisplay.get())->m_error = {};
((UpdateDisplay*)currentDisplay.get())->m_errorValid = true;
((UpdateDisplay*)currentDisplay.get())->redraw();
}
if (final)
{
if (Update.end(true))
{
Serial.printf("Update Success: %uB\r\n", index + len);
((UpdateDisplay*)currentDisplay.get())->m_finished = true;
((UpdateDisplay*)currentDisplay.get())->redraw();
}
else
{
Update.printError(Serial);
((UpdateDisplay*)currentDisplay.get())->m_error = {};
((UpdateDisplay*)currentDisplay.get())->m_errorValid = true;
((UpdateDisplay*)currentDisplay.get())->redraw();
}
}
};
};
webServer.on("/updateCode", HTTP_POST, handleUpdate, createHandleUpdtateUpload((ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000, U_FLASH));
webServer.on("/updateData", HTTP_POST, handleUpdate, createHandleUpdtateUpload(UPDATE_SIZE_UNKNOWN, U_SPIFFS));
#endif
webServer.begin(); webServer.begin();
} }
void handleWebserver() void handleWebserver()
{ {
if (shouldReboot)
{
shouldReboot = false;
ESP.restart();
}
} }
#endif #endif
} }

68
src/changevaluedisplay_bluetoothmode.h
View File

@@ -22,66 +22,30 @@ class ChangeValueDisplay<BluetoothMode> :
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
ChangeValueDisplay();
void start() override; void start() 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};
}; };
ChangeValueDisplay<BluetoothMode>::ChangeValueDisplay()
{
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_OFF>>>(BluetoothMode::Off, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_MASTER>>>(BluetoothMode::Master, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<BluetoothMode>, StaticText<TEXT_SLAVE>>>(BluetoothMode::Slave, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
}
void ChangeValueDisplay<BluetoothMode>::start() void ChangeValueDisplay<BluetoothMode>::start()
{ {
Base::start(); Base::start();
if (getValue() == m_offAction.value()) setSelectedIndex(0); else switch (const auto value = getValue())
if (getValue() == m_masterAction.value()) setSelectedIndex(1); else
if (getValue() == m_slaveAction.value()) setSelectedIndex(2); else
{ {
Serial.printf("Unknown BluetoothMode: %i", int(getValue())); case BluetoothMode::Off: setSelectedIndex(0); break;
case BluetoothMode::Master: setSelectedIndex(1); break;
case BluetoothMode::Slave: setSelectedIndex(2); break;
default:
Serial.printf("Unknown BluetoothMode: %i\r\n", int(value));
setSelectedIndex(4); setSelectedIndex(4);
} }
} }

59
src/changevaluedisplay_bool.h
View File

@@ -19,57 +19,26 @@ class ChangeValueDisplay<bool> :
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
ChangeValueDisplay();
void start() override; void start() 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};
}; };
ChangeValueDisplay<bool>::ChangeValueDisplay()
{
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<bool>, StaticText<TEXT_TRUE>>>(true, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<bool>, StaticText<TEXT_FALSE>>>(false, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
}
void ChangeValueDisplay<bool>::start() void ChangeValueDisplay<bool>::start()
{ {
Base::start(); Base::start();
if (getValue() == m_trueItem.value()) setSelectedIndex(0); else switch (getValue())
if (getValue() == m_falseItem.value()) setSelectedIndex(1); {
case true: setSelectedIndex(0); break;
case false: setSelectedIndex(1); break;
}
} }
} }

76
src/changevaluedisplay_controlmode.h
View File

@@ -18,72 +18,32 @@ class ChangeValueDisplay<ControlMode> :
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
ChangeValueDisplay();
void start() override; void start() 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;
}; };
ChangeValueDisplay<ControlMode>::ChangeValueDisplay()
{
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_OPENMODE>>>(ControlMode::OpenMode, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_VOLTAGE>>>(ControlMode::Voltage, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_SPEED>>>(ControlMode::Speed, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlMode>, StaticText<TEXT_TORQUE>>>(ControlMode::Torque, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
}
void ChangeValueDisplay<ControlMode>::start() void ChangeValueDisplay<ControlMode>::start()
{ {
Base::start(); Base::start();
if (getValue() == m_openModeItem.value()) setSelectedIndex(0); else switch (const auto value = getValue())
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())); case ControlMode::OpenMode: setSelectedIndex(0); break;
case ControlMode::Voltage: setSelectedIndex(1); break;
case ControlMode::Speed: setSelectedIndex(2); break;
case ControlMode::Torque: setSelectedIndex(3); break;
default:
Serial.printf("Unknown ControlMode: %i\r\n", int(value));
setSelectedIndex(4); setSelectedIndex(4);
} }
} }

68
src/changevaluedisplay_controltype.h
View File

@@ -18,66 +18,30 @@ class ChangeValueDisplay<ControlType> :
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
ChangeValueDisplay();
void start() override; void start() 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};
}; };
ChangeValueDisplay<ControlType>::ChangeValueDisplay()
{
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_COMMUTATION>>>(ControlType::Commutation, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_SINUSOIDAL>>>(ControlType::Sinusoidal, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<ControlType>, StaticText<TEXT_FIELDORIENTEDCONTROL>>>(ControlType::FieldOrientedControl, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
}
void ChangeValueDisplay<ControlType>::start() void ChangeValueDisplay<ControlType>::start()
{ {
Base::start(); Base::start();
if (getValue() == m_commutationItem.value()) setSelectedIndex(0); else switch (const auto value = getValue())
if (getValue() == m_sinusoidalItem.value()) setSelectedIndex(1); else
if (getValue() == m_fieldOrientedControlItem.value()) setSelectedIndex(2); else
{ {
Serial.printf("Unknown ControlType: %i", int(getValue())); case ControlType::Commutation: setSelectedIndex(0); break;
case ControlType::Sinusoidal: setSelectedIndex(1); break;
case ControlType::FieldOrientedControl: setSelectedIndex(2); break;
default:
Serial.printf("Unknown ControlType: %i\r\n", int(value));
setSelectedIndex(3); setSelectedIndex(3);
} }
} }

76
src/changevaluedisplay_larsmmode_mode.h
View File

@@ -19,72 +19,32 @@ class ChangeValueDisplay<LarsmModeMode> :
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
ChangeValueDisplay();
void start() override; void start() 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};
}; };
ChangeValueDisplay<LarsmModeMode>::ChangeValueDisplay()
{
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE1>>>(LarsmModeMode::Mode1, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE2>>>(LarsmModeMode::Mode2, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE3>>>(LarsmModeMode::Mode3, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<LarsmModeMode>, StaticText<TEXT_LARSMMODE4>>>(LarsmModeMode::Mode4, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
}
void ChangeValueDisplay<LarsmModeMode>::start() void ChangeValueDisplay<LarsmModeMode>::start()
{ {
Base::start(); Base::start();
if (getValue() == m_larsmMode1Item.value()) setSelectedIndex(0); else switch (const auto value = getValue())
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())); case LarsmModeMode::Mode1: setSelectedIndex(0); break;
case LarsmModeMode::Mode2: setSelectedIndex(1); break;
case LarsmModeMode::Mode3: setSelectedIndex(2); break;
case LarsmModeMode::Mode4: setSelectedIndex(3); break;
default:
Serial.printf("Unknown LarsmModeMode: %i\r\n", int(value));
setSelectedIndex(4); setSelectedIndex(4);
} }
} }

84
src/changevaluedisplay_unifiedmodelmode.h
View File

@@ -19,78 +19,34 @@ class ChangeValueDisplay<UnifiedModelMode> :
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
ChangeValueDisplay();
void start() override; void start() 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};
}; };
ChangeValueDisplay<UnifiedModelMode>::ChangeValueDisplay()
{
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_COMMUTATION>>>(UnifiedModelMode::Commutation, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_SINUSOIDAL>>>(UnifiedModelMode::Sinusoidal, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCVOLTAGE>>>(UnifiedModelMode::FocVoltage, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCSPEED>>>(UnifiedModelMode::FocSpeed, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<UnifiedModelMode>, StaticText<TEXT_FOCTORQUE>>>(UnifiedModelMode::FocTorque, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
}
void ChangeValueDisplay<UnifiedModelMode>::start() void ChangeValueDisplay<UnifiedModelMode>::start()
{ {
Base::start(); Base::start();
if (getValue() == m_commutationItem.value()) setSelectedIndex(0); else switch (const auto value = getValue())
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())); case UnifiedModelMode::Commutation: setSelectedIndex(0); break;
case UnifiedModelMode::Sinusoidal: setSelectedIndex(1); break;
case UnifiedModelMode::FocVoltage: setSelectedIndex(2); break;
case UnifiedModelMode::FocSpeed: setSelectedIndex(3); break;
case UnifiedModelMode::FocTorque: setSelectedIndex(4); break;
default:
Serial.printf("Unknown UnifiedModelMode: %i\r\n", int(value));
setSelectedIndex(5); setSelectedIndex(5);
} }
} }

76
src/changevaluedisplay_wifi_mode_t.h
View File

@@ -20,72 +20,32 @@ class ChangeValueDisplay<wifi_mode_t> :
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
ChangeValueDisplay();
void start() override; void start() 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};
}; };
ChangeValueDisplay<wifi_mode_t>::ChangeValueDisplay()
{
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_NULL>>>(WIFI_MODE_NULL, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_STA>>>(WIFI_MODE_STA, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_AP>>>(WIFI_MODE_AP, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_mode_t>, StaticText<TEXT_WIFI_MODE_APSTA>>>(WIFI_MODE_APSTA, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
}
void ChangeValueDisplay<wifi_mode_t>::start() void ChangeValueDisplay<wifi_mode_t>::start()
{ {
Base::start(); Base::start();
if (getValue() == m_nullItem.value()) setSelectedIndex(0); else switch (const auto value = getValue())
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())); case WIFI_MODE_NULL: setSelectedIndex(0); break;
case WIFI_MODE_STA: setSelectedIndex(1); break;
case WIFI_MODE_AP: setSelectedIndex(2); break;
case WIFI_MODE_APSTA: setSelectedIndex(3); break;
default:
Serial.printf("Unknown wifi_mode_t: %i\r\n", int(value));
setSelectedIndex(4); setSelectedIndex(4);
} }
} }

140
src/changevaluedisplay_wifi_power_t.h
View File

@@ -20,120 +20,48 @@ class ChangeValueDisplay<wifi_power_t> :
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
ChangeValueDisplay();
void start() override; void start() 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};
}; };
ChangeValueDisplay<wifi_power_t>::ChangeValueDisplay()
{
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_19_5dBm>>>(WIFI_POWER_19_5dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_19dBm>>>(WIFI_POWER_19dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_18_5dBm>>>(WIFI_POWER_18_5dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_17dBm>>>(WIFI_POWER_17dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_15dBm>>>(WIFI_POWER_15dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_13dBm>>>(WIFI_POWER_13dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_11dBm>>>(WIFI_POWER_11dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_8_5dBm>>>(WIFI_POWER_8_5dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_7dBm>>>(WIFI_POWER_7dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_5dBm>>>(WIFI_POWER_5dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_2dBm>>>(WIFI_POWER_2dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<wifi_power_t>, StaticText<TEXT_WIFI_POWER_MINUS_1dBm>>>(WIFI_POWER_MINUS_1dBm, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&icons::back>>>(*this);
}
void ChangeValueDisplay<wifi_power_t>::start() void ChangeValueDisplay<wifi_power_t>::start()
{ {
Base::start(); Base::start();
if (getValue() == m_19_5dBmItem.value()) setSelectedIndex(0); else switch (const auto value = getValue())
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())); case WIFI_POWER_19_5dBm: setSelectedIndex(0); break;
case WIFI_POWER_19dBm: setSelectedIndex(1); break;
case WIFI_POWER_18_5dBm: setSelectedIndex(2); break;
case WIFI_POWER_17dBm: setSelectedIndex(3); break;
case WIFI_POWER_15dBm: setSelectedIndex(4); break;
case WIFI_POWER_13dBm: setSelectedIndex(5); break;
case WIFI_POWER_11dBm: setSelectedIndex(6); break;
case WIFI_POWER_8_5dBm: setSelectedIndex(7); break;
case WIFI_POWER_7dBm: setSelectedIndex(8); break;
case WIFI_POWER_5dBm: setSelectedIndex(9); break;
case WIFI_POWER_2dBm: setSelectedIndex(10); break;
case WIFI_POWER_MINUS_1dBm: setSelectedIndex(11); break;
default:
Serial.printf("Unknown wifi_power_t: %i\r\n", int(value));
setSelectedIndex(12); setSelectedIndex(12);
} }
} }

76
src/containermenudefinition.h
View File

@@ -1,76 +0,0 @@
#pragma once
// system includes
#include <vector>
#include <memory>
// local includes
#include "menudefinitioninterface.h"
namespace {
class ContainerMenuDefinition : public virtual MenuDefinitionInterface
{
public:
std::size_t size() const override { return m_items.size(); }
MenuItem& getMenuItem(std::size_t index) override
{
if (index < m_items.size())
return *m_items[index].get();
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const override
{
if (index < m_items.size())
return *m_items[index].get();
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback) override
{
for (const auto &ptr : m_items)
callback(*ptr);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const override
{
for (const auto &ptr : m_items)
callback(*ptr);
}
template<typename T, typename... Args>
T &constructItem(Args&&... args)
{
auto ptr = std::make_unique<T>(std::forward<Args>(args)...);
T &ref = *ptr;
emplaceItem(std::move(ptr));
return ref;
}
void emplaceItem(std::unique_ptr<MenuItem> &&ptr)
{
m_items.emplace_back(std::move(ptr));
}
void clearItems()
{
m_items.clear();
}
std::unique_ptr<MenuItem> takeLast()
{
if (m_items.empty())
throw "aua";
std::unique_ptr<MenuItem> ptr = std::move(m_items.back());
m_items.pop_back();
return ptr;
}
private:
std::vector<std::unique_ptr<MenuItem>> m_items;
};
} // namespace

67
src/displays/gameoflifedisplay.h
View File

@@ -46,34 +46,37 @@ private:
static const constexpr auto GEN_DELAY = 0; static const constexpr auto GEN_DELAY = 0;
template<typename T> auto index(T x, T y) int index(int x, int y)
{ {
if (x >= GRIDX) if (x >= GRIDX)
{ {
Serial.printf("x: %i", x); Serial.printf("x: %i\r\n", x);
return 0; return 0;
} }
if (y >= GRIDY) if (y >= GRIDY)
{ {
Serial.printf("y: %i", x); Serial.printf("y: %i\r\n", x);
return 0; return 0;
} }
return (x * GRIDX) + y; const auto result = (x * GRIDY) + y;
if (result >= GRIDX*GRIDY)
{
Serial.printf("x:%i y:%i x*y:%i\r\n", x, y, result);
return 0;
}
return result;
} }
struct Data std::unique_ptr<std::bitset<GRIDX*GRIDY>> m_grid;
{ std::unique_ptr<std::bitset<GRIDX*GRIDY>> m_newgrid;
std::bitset<GRIDX*GRIDY> grid, newgrid;
};
std::unique_ptr<Data> m_data;
int gen = 0; int gen = 0;
}; };
void GameOfLifeDisplay::start() void GameOfLifeDisplay::start()
{ {
m_data = std::make_unique<Data>(); m_grid = std::make_unique<std::bitset<GRIDX*GRIDY>>();
m_newgrid = std::make_unique<std::bitset<GRIDX*GRIDY>>();
} }
void GameOfLifeDisplay::initScreen() void GameOfLifeDisplay::initScreen()
@@ -93,21 +96,17 @@ void GameOfLifeDisplay::redraw()
computeCA(); computeCA();
drawGrid(); drawGrid();
m_data->grid = m_data->newgrid; *m_grid = *m_newgrid;
// for (int16_t x = 1; x < GRIDX-1; x++) {
// for (int16_t y = 1; y < GRIDY-1; y++) {
// grid[index(x,y)] = m_data->newgrid[index(x,y)];
// }
// }
if (++gen == 200) if (++gen == 500)
gen = 0; gen = 0;
} }
void GameOfLifeDisplay::stop() void GameOfLifeDisplay::stop()
{ {
tft.setRotation(0); tft.setRotation(0);
m_data = nullptr; m_grid = nullptr;
m_newgrid = nullptr;
} }
void GameOfLifeDisplay::drawGrid() void GameOfLifeDisplay::drawGrid()
@@ -115,8 +114,8 @@ void GameOfLifeDisplay::drawGrid()
uint16_t color = TFT_WHITE; uint16_t color = TFT_WHITE;
for (int16_t x = 1; x < GRIDX - 1; x++) { for (int16_t x = 1; x < GRIDX - 1; x++) {
for (int16_t y = 1; y < GRIDY - 1; y++) { for (int16_t y = 1; y < GRIDY - 1; y++) {
if ((m_data->grid[index(x,y)]) != (m_data->newgrid[index(x,y)])) { if (((*m_grid)[index(x,y)]) != ((*m_newgrid)[index(x,y)])) {
if (m_data->newgrid[index(x,y)] == 1) if ((*m_newgrid)[index(x,y)] == 1)
color = 0xFFFF; //random(0xFFFF); color = 0xFFFF; //random(0xFFFF);
else else
color = 0; color = 0;
@@ -130,16 +129,16 @@ void GameOfLifeDisplay::initGrid()
{ {
for (int16_t x = 0; x < GRIDX; x++) { for (int16_t x = 0; x < GRIDX; x++) {
for (int16_t y = 0; y < GRIDY; y++) { for (int16_t y = 0; y < GRIDY; y++) {
m_data->newgrid[index(x,y)] = 0; (*m_newgrid)[index(x,y)] = 0;
if (x == 0 || x == GRIDX - 1 || y == 0 || y == GRIDY - 1) if (x == 0 || x == GRIDX - 1 || y == 0 || y == GRIDY - 1)
m_data->grid[index(x,y)] = 0; (*m_grid)[index(x,y)] = 0;
else else
{ {
if (random(3) == 1) if (random(3) == 1)
m_data->grid[index(x,y)] = 1; (*m_grid)[index(x,y)] = 1;
else else
m_data->grid[index(x,y)] = 0; (*m_grid)[index(x,y)] = 0;
} }
} }
@@ -160,7 +159,7 @@ int GameOfLifeDisplay::getNumberOfNeighbors(int x, int y)
if (new_x >= 0 && new_y >= 0 && if (new_x >= 0 && new_y >= 0 &&
new_x < GRIDX && new_y < GRIDY) new_x < GRIDX && new_y < GRIDY)
n += m_data->grid[index(new_x, new_y)]; n += (*m_grid)[index(new_x, new_y)];
} }
return n; return n;
@@ -171,14 +170,14 @@ void GameOfLifeDisplay::computeCA()
for (int16_t x = 1; x < GRIDX; x++) { for (int16_t x = 1; x < GRIDX; x++) {
for (int16_t y = 1; y < GRIDY; y++) { for (int16_t y = 1; y < GRIDY; y++) {
int neighbors = getNumberOfNeighbors(x, y); int neighbors = getNumberOfNeighbors(x, y);
if (m_data->grid[index(x,y)] == true && (neighbors == 2 || neighbors == 3 )) if ((*m_grid)[index(x,y)] == true && (neighbors == 2 || neighbors == 3 ))
m_data->newgrid[index(x,y)] = true; (*m_newgrid)[index(x,y)] = true;
else if (m_data->grid[index(x,y)] == 1) else if ((*m_grid)[index(x,y)] == 1)
m_data->newgrid[index(x,y)] = false; (*m_newgrid)[index(x,y)] = false;
if (m_data->grid[index(x,y)] == false && (neighbors == 3)) if ((*m_grid)[index(x,y)] == false && (neighbors == 3))
m_data->newgrid[index(x,y)] = true; (*m_newgrid)[index(x,y)] = true;
else if (m_data->grid[index(x,y)] == 0) else if ((*m_grid)[index(x,y)] == 0)
m_data->newgrid[index(x,y)] = false; (*m_newgrid)[index(x,y)] = false;
} }
} }
} }

48
src/displays/menus/aboutmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
@@ -22,34 +21,33 @@ constexpr char TEXT_ESPINFO[] = "ESP info:";
class AboutMenu : class AboutMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_ABOUT>, public StaticText<TEXT_ABOUT>,
public BackActionInterface<SwitchScreenAction<SettingsMenu>>, public BackActionInterface<SwitchScreenAction<SettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
AboutMenu() AboutMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_VERSION>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VERSION>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_ESPINFO>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPINFO>, DummyAction>>();
constructItem<makeComponent<MenuItem, EspHeapSizeText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspHeapSizeText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspFreeHeapText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspFreeHeapText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspMinFreeHeapText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspMinFreeHeapText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspMaxAllocHeapText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspMaxAllocHeapText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspPsramSizeText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspPsramSizeText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspFreePsramText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspFreePsramText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspMinFreePsramText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspMinFreePsramText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspMaxAllocPsramText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspMaxAllocPsramText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspChipRevisionText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspChipRevisionText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspCpuFreqMHzText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspCpuFreqMHzText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspCycleCountText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspCycleCountText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspSdkVersionText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspSdkVersionText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspFlashChipSizeText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspFlashChipSizeText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspFlashChipSpeedText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspFlashChipSpeedText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspFlashChipModeText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspFlashChipModeText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspSketchSizeText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspSketchSizeText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspSketchMd5Text, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspSketchMd5Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, EspFreeSketchSpaceText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, EspFreeSketchSpaceText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

30
src/displays/menus/accesspointwifisettingsmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
#include "actions/wifisoftapaction.h" #include "actions/wifisoftapaction.h"
@@ -23,25 +22,24 @@ namespace {
class AccessPointWifiSettingsMenu : class AccessPointWifiSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_ACCESSPOINTWIFISETTINGS>, public StaticText<TEXT_ACCESSPOINTWIFISETTINGS>,
public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>, public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
AccessPointWifiSettingsMenu() AccessPointWifiSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAP>, WifiSoftApAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAP>, WifiSoftApAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECT>, WifiSoftApDisconnectAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECT>, WifiSoftApDisconnectAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECTWIFIOFF>, WifiSoftApDisconnectWifioffAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECTWIFIOFF>, WifiSoftApDisconnectWifioffAction>>();
constructItem<makeComponent<MenuItem, WifiSoftApGetStationNumText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSoftApGetStationNumText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiSoftApIpText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSoftApIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiSoftApBroadcastIpText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSoftApBroadcastIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiSoftApNetworkIdText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSoftApNetworkIdText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiSoftApSubnetCidrText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSoftApSubnetCidrText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPENABLEIPV6>, WifiSoftApEnableIpV6Action>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPENABLEIPV6>, WifiSoftApEnableIpV6Action>>();
constructItem<makeComponent<MenuItem, WifiSoftApIpV6Text, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSoftApIpV6Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiSoftApHostnameText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSoftApHostnameText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiSoftApMacAddressText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSoftApMacAddressText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

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

@@ -3,7 +3,6 @@
// local includes // local includes
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
#ifdef FEATURE_BLUETOOTH #ifdef FEATURE_BLUETOOTH
@@ -39,24 +38,23 @@ using AutoBluetoothModeChangeDisplay = makeComponent<
class BluetoothSettingsMenu : class BluetoothSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_BLUETOOTHSETTINGS>, public StaticText<TEXT_BLUETOOTHSETTINGS>,
public BackActionInterface<SwitchScreenAction<SettingsMenu>>, public BackActionInterface<SwitchScreenAction<SettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
BluetoothSettingsMenu() BluetoothSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, BluetoothAvailableText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, BluetoothAvailableText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, BluetoothHasClientText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, BluetoothHasClientText, DisabledColor, DummyAction>>();
// constructItem<makeComponent<MenuItem, BluetoothConnectedText, DisabledColor, DummyAction>>(); // crashes // constructItem<makeComponent<MenuItem, BluetoothConnectedText, DisabledColor, DummyAction>>(); // crashes
constructItem<makeComponent<MenuItem, BluetoothIsReadyText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, BluetoothIsReadyText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, BluetoothIsReadyMasterText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, BluetoothIsReadyMasterText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGIN>, BluetoothBeginAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGIN>, BluetoothBeginAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGINMASTER>, BluetoothBeginMasterAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHBEGINMASTER>, BluetoothBeginMasterAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHFLUSH>, BluetoothFlushAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHFLUSH>, BluetoothFlushAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHEND>, BluetoothEndAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHEND>, BluetoothEndAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHDISCONNECT>, BluetoothDisconnectAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHDISCONNECT>, BluetoothDisconnectAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_AUTOBLUETOOTHMODE>, SwitchScreenAction<AutoBluetoothModeChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOBLUETOOTHMODE>, SwitchScreenAction<AutoBluetoothModeChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
#endif #endif

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

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#ifdef FEATURE_BLUETOOTH #ifdef FEATURE_BLUETOOTH
@@ -29,20 +28,19 @@ namespace {
class BmsMenu : class BmsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_BMS>, public StaticText<TEXT_BMS>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>
public ContainerMenuDefinition
{ {
public: public:
BmsMenu() BmsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_CONNECTBMS>, BluetoothConnectBmsAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONNECTBMS>, BluetoothConnectBmsAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DISCONNECTBMS>, BluetoothDisconnectAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISCONNECTBMS>, BluetoothDisconnectAction>>();
constructItem<makeComponent<MenuItem, BluetoothHasClientText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, BluetoothHasClientText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_TURNONCHARGE>, BmsTurnOnChargeAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNONCHARGE>, BmsTurnOnChargeAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFCHARGE>, BmsTurnOffChargeAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFCHARGE>, BmsTurnOffChargeAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_TURNONDISCHARGE>, BmsTurnOnDischargeAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNONDISCHARGE>, BmsTurnOnDischargeAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFDISCHARGE>, BmsTurnOffDischargeAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFDISCHARGE>, BmsTurnOffDischargeAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
#endif #endif

30
src/displays/menus/boardcomputerhardwaresettingsmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
@@ -139,22 +138,21 @@ using GametrakDistMaxChangeScreen = makeComponent<
class BoardcomputerHardwareSettingsMenu : class BoardcomputerHardwareSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>, public StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>,
public BackActionInterface<SwitchScreenAction<SettingsMenu>>, public BackActionInterface<SwitchScreenAction<SettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
BoardcomputerHardwareSettingsMenu() BoardcomputerHardwareSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, GasText, DisabledColor, StaticFont<2>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, GasText, DisabledColor, StaticFont<2>, DummyAction>>();
constructItem<makeComponent<MenuItem, BremsText, DisabledColor, StaticFont<2>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, BremsText, DisabledColor, StaticFont<2>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_CALIBRATE>, SwitchScreenAction<CalibrateDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CALIBRATE>, SwitchScreenAction<CalibrateDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETSAMPLECOUNT>, SwitchScreenAction<SampleCountChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETSAMPLECOUNT>, SwitchScreenAction<SampleCountChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMIN>, SwitchScreenAction<GasMinChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMIN>, SwitchScreenAction<GasMinChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMAX>, SwitchScreenAction<GasMaxChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMAX>, SwitchScreenAction<GasMaxChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMIN>, SwitchScreenAction<BremsMinChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMIN>, SwitchScreenAction<BremsMinChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMAX>, SwitchScreenAction<BremsMaxChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMAX>, SwitchScreenAction<BremsMaxChangeScreen>>>();
#if defined(FEATURE_DPAD) || defined(FEATURE_DPAD_3WIRESW) || defined(FEATURE_DPAD_5WIRESW) #if defined(FEATURE_DPAD) || defined(FEATURE_DPAD_3WIRESW) || defined(FEATURE_DPAD_5WIRESW)
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETDPADDEBOUNCE>, SwitchScreenAction<DPadDebounceChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETDPADDEBOUNCE>, SwitchScreenAction<DPadDebounceChangeScreen>>>();
#endif #endif
#ifdef FEATURE_GAMETRAK #ifdef FEATURE_GAMETRAK
constructItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>, constructItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>,
@@ -169,10 +167,10 @@ public:
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMIN>, SwitchScreenAction<GametrakDistMinChangeScreen>>>(); constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMIN>, SwitchScreenAction<GametrakDistMinChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMAX>, SwitchScreenAction<GametrakDistMaxChangeScreen>>>(); constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMAX>, SwitchScreenAction<GametrakDistMaxChangeScreen>>>();
#endif #endif
constructItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SWAPSCREENBYTES>, ToggleBoolAction, CheckboxIcon, SwapScreenBytesAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPSCREENBYTES>, ToggleBoolAction, CheckboxIcon, SwapScreenBytesAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_TIMERS>, SwitchScreenAction<TimersMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TIMERS>, SwitchScreenAction<TimersMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

24
src/displays/menus/buzzermenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "menuitem.h" #include "menuitem.h"
@@ -89,22 +88,21 @@ using ReverseBeepDuration1ChangeScreen = makeComponent<
class BuzzerMenu : class BuzzerMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_BUZZER>, public StaticText<TEXT_BUZZER>,
public BackActionInterface<SwitchScreenAction<SettingsMenu>>, public BackActionInterface<SwitchScreenAction<SettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
BuzzerMenu() BuzzerMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTFREQ>, SwitchScreenAction<FrontFreqChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTFREQ>, SwitchScreenAction<FrontFreqChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTPATTERN>, SwitchScreenAction<FrontPatternChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTPATTERN>, SwitchScreenAction<FrontPatternChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKFREQ>, SwitchScreenAction<BackFreqChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKFREQ>, SwitchScreenAction<BackFreqChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKPATTERN>, SwitchScreenAction<BackPatternChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKPATTERN>, SwitchScreenAction<BackPatternChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEP>, ToggleBoolAction, CheckboxIcon, ReverseBeepAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEP>, ToggleBoolAction, CheckboxIcon, ReverseBeepAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ0>, SwitchScreenAction<ReverseBeepFreq0ChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ0>, SwitchScreenAction<ReverseBeepFreq0ChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ1>, SwitchScreenAction<ReverseBeepFreq1ChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPFREQ1>, SwitchScreenAction<ReverseBeepFreq1ChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION0>, SwitchScreenAction<ReverseBeepDuration0ChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION0>, SwitchScreenAction<ReverseBeepDuration0ChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION1>, SwitchScreenAction<ReverseBeepDuration1ChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REVERSEBEEPDURATION1>, SwitchScreenAction<ReverseBeepDuration1ChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

14
src/displays/menus/commanddebugmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
@@ -21,17 +20,16 @@ template<const char *Ttext, typename Ttexts>
class CommandDebugMenu : class CommandDebugMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<Ttext>, public StaticText<Ttext>,
public BackActionInterface<SwitchScreenAction<DebugMenu>>, public BackActionInterface<SwitchScreenAction<DebugMenu>>
public ContainerMenuDefinition
{ {
public: public:
CommandDebugMenu() CommandDebugMenu()
{ {
constructItem<makeComponent<MenuItem, typename Ttexts::BuzzerFreqText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::BuzzerFreqText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::BuzzerPatternText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::BuzzerPatternText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::PoweroffText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::PoweroffText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::LedText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::LedText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };

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

@@ -4,7 +4,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "actions/toggleboolaction.h" #include "actions/toggleboolaction.h"
@@ -51,19 +50,18 @@ using NumMagnetPolesChangeScreen = makeComponent<
class ControllerHardwareSettingsMenu : class ControllerHardwareSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_CONTROLLERHARDWARESETTINGS>, public StaticText<TEXT_CONTROLLERHARDWARESETTINGS>,
public BackActionInterface<SwitchScreenAction<SettingsMenu>>, public BackActionInterface<SwitchScreenAction<SettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
ControllerHardwareSettingsMenu() ControllerHardwareSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETENABLED>, SwitchScreenAction<EnableMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETENABLED>, SwitchScreenAction<EnableMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETINVERTED>, SwitchScreenAction<InvertMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETINVERTED>, SwitchScreenAction<InvertMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERMM>, SwitchScreenAction<WheelDiameterMmChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERMM>, SwitchScreenAction<WheelDiameterMmChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERINCH>, SwitchScreenAction<WheelDiameterInchChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERINCH>, SwitchScreenAction<WheelDiameterInchChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_NUMMAGNETPOLES>, SwitchScreenAction<NumMagnetPolesChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NUMMAGNETPOLES>, SwitchScreenAction<NumMagnetPolesChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SWAPFRONTBACK>, ToggleBoolAction, CheckboxIcon, SwapFrontBackAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPFRONTBACK>, ToggleBoolAction, CheckboxIcon, SwapFrontBackAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

48
src/displays/menus/debugmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/loadsettingsaction.h" #include "actions/loadsettingsaction.h"
@@ -39,34 +38,33 @@ namespace {
class DebugMenu : class DebugMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_DEBUG>, public StaticText<TEXT_DEBUG>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>
public ContainerMenuDefinition
{ {
public: public:
DebugMenu() DebugMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_LOADSETTINGS>, LoadSettingsAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOADSETTINGS>, LoadSettingsAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SAVESETTINGS>, SaveSettingsAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SAVESETTINGS>, SaveSettingsAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_ERASENVS>, EraseNvsAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ERASENVS>, EraseNvsAction>>();
constructItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTCOMMAND>, SwitchScreenAction<FrontCommandDebugMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTCOMMAND>, SwitchScreenAction<FrontCommandDebugMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKCOMMAND>, SwitchScreenAction<BackCommandDebugMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKCOMMAND>, SwitchScreenAction<BackCommandDebugMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTCOMMAND>, SwitchScreenAction<FrontLeftMotorStateDebugMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTCOMMAND>, SwitchScreenAction<FrontLeftMotorStateDebugMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTCOMMAND>, SwitchScreenAction<FrontRightMotorStateDebugMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTCOMMAND>, SwitchScreenAction<FrontRightMotorStateDebugMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKLEFTCOMMAND>, SwitchScreenAction<BackLeftMotorStateDebugMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLEFTCOMMAND>, SwitchScreenAction<BackLeftMotorStateDebugMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTCOMMAND>, SwitchScreenAction<BackRightMotorStateDebugMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTCOMMAND>, SwitchScreenAction<BackRightMotorStateDebugMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTFEEDBACK>, SwitchScreenAction<FrontFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTFEEDBACK>, SwitchScreenAction<FrontFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKFEEDBACK>, SwitchScreenAction<BackFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKFEEDBACK>, SwitchScreenAction<BackFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
constructItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTFEEDBACK>, SwitchScreenAction<FrontLeftMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLEFTFEEDBACK>, SwitchScreenAction<FrontLeftMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTFEEDBACK>, SwitchScreenAction<FrontRightMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTRIGHTFEEDBACK>, SwitchScreenAction<FrontRightMotorFeedbackDebugMenu>, FrontFeedbackColor<TFT_WHITE>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKLEFTFEEDBACK>, SwitchScreenAction<BackLeftMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLEFTFEEDBACK>, SwitchScreenAction<BackLeftMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTFEEDBACK>, SwitchScreenAction<BackRightMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKRIGHTFEEDBACK>, SwitchScreenAction<BackRightMotorFeedbackDebugMenu>, BackFeedbackColor<TFT_WHITE>>>();
constructItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<nullptr>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICMENU>, SwitchScreenAction<DynamicDebugMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICMENU>, SwitchScreenAction<DynamicDebugMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

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

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "menuitem.h" #include "menuitem.h"
@@ -87,25 +86,24 @@ using DefaultModeBrems2WertChangeDisplay = makeComponent<
class DefaultModeSettingsMenu : class DefaultModeSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_DEFAULTMODESETTIGNS>, public StaticText<TEXT_DEFAULTMODESETTIGNS>,
public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>, public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
DefaultModeSettingsMenu() DefaultModeSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<DefaultModeModelModeChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<DefaultModeModelModeChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>, ToggleBoolAction, CheckboxIcon, DefaultModeSquareGasAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREGAS>, ToggleBoolAction, CheckboxIcon, DefaultModeSquareGasAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>, ToggleBoolAction, CheckboxIcon, DefaultModeSquareBremsAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SQUAREBREMS>, ToggleBoolAction, CheckboxIcon, DefaultModeSquareBremsAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHING>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLESMOOTHING>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableSmoothingAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETSMOOTHING>, SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETSMOOTHING>, SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETFRONTPERCENTAGE>, SwitchScreenAction<DefaultModeFrontPercentageChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETFRONTPERCENTAGE>, SwitchScreenAction<DefaultModeFrontPercentageChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBACKPERCENTAGE>, SwitchScreenAction<DefaultModeBackPercentageChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBACKPERCENTAGE>, SwitchScreenAction<DefaultModeBackPercentageChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETADDSCHWELLE>, SwitchScreenAction<DefaultModeAddSchwelleChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETADDSCHWELLE>, SwitchScreenAction<DefaultModeAddSchwelleChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAS1WERT>, SwitchScreenAction<DefaultModeGas1WertChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAS1WERT>, SwitchScreenAction<DefaultModeGas1WertChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETGAS2WERT>, SwitchScreenAction<DefaultModeGas2WertChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAS2WERT>, SwitchScreenAction<DefaultModeGas2WertChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMS1WERT>, SwitchScreenAction<DefaultModeBrems1WertChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMS1WERT>, SwitchScreenAction<DefaultModeBrems1WertChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMS2WERT>, SwitchScreenAction<DefaultModeBrems2WertChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMS2WERT>, SwitchScreenAction<DefaultModeBrems2WertChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

14
src/displays/menus/demosmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
@@ -22,17 +21,16 @@ namespace {
class DemosMenu : class DemosMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_DEMOS>, public StaticText<TEXT_DEMOS>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>
public ContainerMenuDefinition
{ {
public: public:
DemosMenu() DemosMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_STARFIELD>, SwitchScreenAction<StarfieldDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STARFIELD>, SwitchScreenAction<StarfieldDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_PINGPONG>, SwitchScreenAction<PingPongDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PINGPONG>, SwitchScreenAction<PingPongDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SPIRO>, SwitchScreenAction<SpiroDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SPIRO>, SwitchScreenAction<SpiroDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_GAMEOFLIFE>, SwitchScreenAction<GameOfLifeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAMEOFLIFE>, SwitchScreenAction<GameOfLifeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

44
src/displays/menus/dynamicdebugmenu.h
View File

@@ -6,7 +6,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
@@ -125,38 +124,37 @@ constexpr char TEXT_DEBUGTOGGLE[] = "Toggle";
class DynamicDebugMenu : class DynamicDebugMenu :
public MenuDisplay, public MenuDisplay,
public RandomText, public RandomText,
public BackActionInterface<SwitchScreenAction<DebugMenu>>, public BackActionInterface<SwitchScreenAction<DebugMenu>>
public ContainerMenuDefinition
{ {
public: public:
DynamicDebugMenu() DynamicDebugMenu()
{ {
// dummy items to allow for scrolling // dummy items to allow for scrolling
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
// the interesting bits // the interesting bits
constructItem<makeComponent<MenuItem, RandomText, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, RandomText, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICCOLOR>, RandomColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICCOLOR>, RandomColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICFONT>, RandomFont, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICFONT>, RandomFont, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICICON>, RandomIcon, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DYNAMICICON>, RandomIcon, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_STATICICON>, StaticMenuItemIcon<&icons::lock>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATICICON>, StaticMenuItemIcon<&icons::lock>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEBUGTOGGLE>, ToggleBoolAction, CheckboxIcon, ToggleAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUGTOGGLE>, ToggleBoolAction, CheckboxIcon, ToggleAccessor>>();
constructItem<makeComponent<MenuItem, RandomText, RandomColor, RandomFont, RandomIcon, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, RandomText, RandomColor, RandomFont, RandomIcon, DummyAction>>();
// more scrolling // more scrolling
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DUMMYITEM>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

14
src/displays/menus/enablemenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/toggleboolaction.h" #include "actions/toggleboolaction.h"
@@ -21,17 +20,16 @@ namespace {
class EnableMenu : class EnableMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_SETENABLED>, public StaticText<TEXT_SETENABLED>,
public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>, public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
EnableMenu() EnableMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>, ToggleBoolAction, CheckboxIcon, FrontLeftEnabledAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>, ToggleBoolAction, CheckboxIcon, FrontLeftEnabledAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightEnabledAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightEnabledAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>, ToggleBoolAction, CheckboxIcon, BackLeftEnabledAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>, ToggleBoolAction, CheckboxIcon, BackLeftEnabledAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>, ToggleBoolAction, CheckboxIcon, BackRightEnabledAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>, ToggleBoolAction, CheckboxIcon, BackRightEnabledAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

16
src/displays/menus/feedbackdebugmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
@@ -22,18 +21,17 @@ template<const char *Ttext, typename Ttexts, template<int> class ColorInterface>
class FeedbackDebugMenu : class FeedbackDebugMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<Ttext>, public StaticText<Ttext>,
public BackActionInterface<SwitchScreenAction<DebugMenu>>, public BackActionInterface<SwitchScreenAction<DebugMenu>>
public ContainerMenuDefinition
{ {
public: public:
FeedbackDebugMenu() FeedbackDebugMenu()
{ {
constructItem<makeComponent<MenuItem, typename Ttexts::BatVoltageText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::BatVoltageText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::BatVoltageFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::BatVoltageFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::BoardTempText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::BoardTempText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::BoardTempFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::BoardTempFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::TimeoutCntSerialText, StaticFont<2>, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::TimeoutCntSerialText, StaticFont<2>, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };

4
src/displays/menus/gametrakmodesettingsmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
@@ -19,8 +18,7 @@ namespace {
class ContainerModeSettingsMenu : class ContainerModeSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_GAMETRAKMODESETTINGS>, public StaticText<TEXT_GAMETRAKMODESETTINGS>,
public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>, public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
ContainerModeSettingsMenu() ContainerModeSettingsMenu()

16
src/displays/menus/genericwifisettingsmenu.h
View File

@@ -5,7 +5,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
@@ -43,18 +42,17 @@ using WifiTxPowerChangeScreen = makeComponent<
class GenericWifiSettingsMenu : class GenericWifiSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_GENERICWIFISETTINGS>, public StaticText<TEXT_GENERICWIFISETTINGS>,
public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>, public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
GenericWifiSettingsMenu() GenericWifiSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, WifiStatusBitsText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiStatusBitsText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiChannelText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiChannelText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEMODE>, SwitchScreenAction<WifiModeChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEMODE>, SwitchScreenAction<WifiModeChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGESLEEP>, ToggleBoolAction, CheckboxIcon, WifiSleepAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGESLEEP>, ToggleBoolAction, CheckboxIcon, WifiSleepAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGETXPOWER>, SwitchScreenAction<WifiTxPowerChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGETXPOWER>, SwitchScreenAction<WifiTxPowerChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

38
src/displays/menus/graphsmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
#include "icons/back.h" #include "icons/back.h"
@@ -150,31 +149,30 @@ using MotorCurrentsGraphDisplay = makeComponent<
class GraphsMenu : class GraphsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_GRAPHS>, public StaticText<TEXT_GRAPHS>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>
public ContainerMenuDefinition
{ {
public: public:
GraphsMenu() GraphsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_GAS>, SwitchScreenAction<GasGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAS>, SwitchScreenAction<GasGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BREMS>, SwitchScreenAction<BremsGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BREMS>, SwitchScreenAction<BremsGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>, SwitchScreenAction<PotisGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>, SwitchScreenAction<PotisGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>, SwitchScreenAction<PotisSplitGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>, SwitchScreenAction<PotisSplitGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_AVGSPEED>, SwitchScreenAction<AvgSpeedGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AVGSPEED>, SwitchScreenAction<AvgSpeedGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_AVGSPEEDKMH>, SwitchScreenAction<AvgSpeedKmhGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AVGSPEEDKMH>, SwitchScreenAction<AvgSpeedKmhGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SUMCURRENT>, SwitchScreenAction<SumCurrentGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SUMCURRENT>, SwitchScreenAction<SumCurrentGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTVOLTAGE>, SwitchScreenAction<FrontVoltageGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTVOLTAGE>, SwitchScreenAction<FrontVoltageGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKVOLTAGE>, SwitchScreenAction<BackVoltageGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKVOLTAGE>, SwitchScreenAction<BackVoltageGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>, SwitchScreenAction<VoltagesGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>, SwitchScreenAction<VoltagesGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>, SwitchScreenAction<VoltagesSplitGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGES>, SwitchScreenAction<VoltagesSplitGraphDisplay>>>();
#ifdef FEATURE_BMS #ifdef FEATURE_BMS
constructItem<makeComponent<MenuItem, StaticText<TEXT_BMSVOLTAGE>, SwitchScreenAction<BmsVoltageGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMSVOLTAGE>, SwitchScreenAction<BmsVoltageGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BMSCURRENT>, SwitchScreenAction<BmsCurrentGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMSCURRENT>, SwitchScreenAction<BmsCurrentGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BMSPOWER>, SwitchScreenAction<BmsPowerGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMSPOWER>, SwitchScreenAction<BmsPowerGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SUMCURRENTSCOMPARISON>, SwitchScreenAction<SumCurrentsComparisonGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SUMCURRENTSCOMPARISON>, SwitchScreenAction<SumCurrentsComparisonGraphDisplay>>>();
#endif #endif
constructItem<makeComponent<MenuItem, StaticText<TEXT_MOTORCURRENTS>, SwitchScreenAction<MotorCurrentsGraphDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOTORCURRENTS>, SwitchScreenAction<MotorCurrentsGraphDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

14
src/displays/menus/invertmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/toggleboolaction.h" #include "actions/toggleboolaction.h"
@@ -21,17 +20,16 @@ namespace {
class InvertMenu : class InvertMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_SETINVERTED>, public StaticText<TEXT_SETINVERTED>,
public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>, public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
InvertMenu() InvertMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTLEFT>, ToggleBoolAction, CheckboxIcon, FrontLeftInvertedAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTLEFT>, ToggleBoolAction, CheckboxIcon, FrontLeftInvertedAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightInvertedAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightInvertedAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>, ToggleBoolAction, CheckboxIcon, BackLeftInvertedAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>, ToggleBoolAction, CheckboxIcon, BackLeftInvertedAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>, ToggleBoolAction, CheckboxIcon, BackRightInvertedAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>, ToggleBoolAction, CheckboxIcon, BackRightInvertedAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

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

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "menuitem.h" #include "menuitem.h"
@@ -43,16 +42,15 @@ using LarsmModeIterationsChangeDisplay = makeComponent<
class LarsmModeSettingsMenu : class LarsmModeSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_LARSMMODESETTINGS>, public StaticText<TEXT_LARSMMODESETTINGS>,
public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>, public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
LarsmModeSettingsMenu() LarsmModeSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<LarsmModeModelModeChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<LarsmModeModelModeChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETMODE>, SwitchScreenAction<LarsmModeModeChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETMODE>, SwitchScreenAction<LarsmModeModeChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETITERATIONS>, SwitchScreenAction<LarsmModeIterationsChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETITERATIONS>, SwitchScreenAction<LarsmModeIterationsChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

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

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "menuitem.h" #include "menuitem.h"
@@ -64,19 +63,18 @@ using PhaseAdvMaxChangeScreen = makeComponent<
class LimitsSettingsMenu : class LimitsSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_LIMITSSETTINGS>, public StaticText<TEXT_LIMITSSETTINGS>,
public BackActionInterface<SwitchScreenAction<SettingsMenu>>, public BackActionInterface<SwitchScreenAction<SettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
LimitsSettingsMenu() LimitsSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETIMOTMAX>, SwitchScreenAction<IMotMaxChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETIMOTMAX>, SwitchScreenAction<IMotMaxChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETIDCMAX>, SwitchScreenAction<IDcMaxChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETIDCMAX>, SwitchScreenAction<IDcMaxChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAXKMH>, SwitchScreenAction<NMotMaxKmhChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAXKMH>, SwitchScreenAction<NMotMaxKmhChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAX>, SwitchScreenAction<NMotMaxRpmChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETNMOTMAX>, SwitchScreenAction<NMotMaxRpmChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETFIELDWEAKMAX>, SwitchScreenAction<FieldWeakMaxChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETFIELDWEAKMAX>, SwitchScreenAction<FieldWeakMaxChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETPHASEADVMAX>, SwitchScreenAction<PhaseAdvMaxChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETPHASEADVMAX>, SwitchScreenAction<PhaseAdvMaxChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

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

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
#include "actions/modesettingsaction.h" #include "actions/modesettingsaction.h"
@@ -39,30 +38,29 @@ namespace {
class MainMenu : class MainMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_MAINMENU>, public StaticText<TEXT_MAINMENU>,
public BackActionInterface<SwitchScreenAction<StatusDisplay>>, public BackActionInterface<SwitchScreenAction<StatusDisplay>>
public ContainerMenuDefinition
{ {
public: public:
MainMenu() MainMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_STATUS>, SwitchScreenAction<StatusDisplay>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATUS>, SwitchScreenAction<StatusDisplay>, StaticMenuItemIcon<&icons::back>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SELECTMODE>, SwitchScreenAction<SelectModeMenu>, StaticMenuItemIcon<&icons::modes>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECTMODE>, SwitchScreenAction<SelectModeMenu>, StaticMenuItemIcon<&icons::modes>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_MODESETTINGS>, ModeSettingsAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODESETTINGS>, ModeSettingsAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_PRESETS>, SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&icons::presets>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PRESETS>, SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&icons::presets>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILES>, SwitchScreenAction<ProfilesMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILES>, SwitchScreenAction<ProfilesMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_GRAPHS>, SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&icons::graph>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GRAPHS>, SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&icons::graph>>>();
#ifdef FEATURE_BMS #ifdef FEATURE_BMS
constructItem<makeComponent<MenuItem, StaticText<TEXT_BMS>, SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&icons::bms>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMS>, SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&icons::bms>>>();
#endif #endif
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETTINGS>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::settings>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETTINGS>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::settings>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_LOCKVEHICLE>, SwitchScreenAction<Lockscreen>, StaticMenuItemIcon<&icons::lock>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOCKVEHICLE>, SwitchScreenAction<Lockscreen>, StaticMenuItemIcon<&icons::lock>>>();
#ifdef FEATURE_MOSFETS #ifdef FEATURE_MOSFETS
constructItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETS>, SwitchScreenAction<MosfetsMenu>>>(); constructItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETS>, SwitchScreenAction<MosfetsMenu>>>();
#endif #endif
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEMOS>, SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&icons::demos>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEMOS>, SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&icons::demos>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_POWEROFF>, SwitchScreenAction<PoweroffDisplay>, StaticMenuItemIcon<&icons::poweroff>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POWEROFF>, SwitchScreenAction<PoweroffDisplay>, StaticMenuItemIcon<&icons::poweroff>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_REBOOT>, RebootAction, StaticMenuItemIcon<&icons::reboot>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REBOOT>, RebootAction, StaticMenuItemIcon<&icons::reboot>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEBUG>, SwitchScreenAction<DebugMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUG>, SwitchScreenAction<DebugMenu>>>();
} }
}; };
} // namespace } // namespace

12
src/displays/menus/modessettingsmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
#include "icons/back.h" #include "icons/back.h"
@@ -21,19 +20,18 @@ namespace {
class ModesSettingsMenu : class ModesSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_MODESSETTINGS>, public StaticText<TEXT_MODESSETTINGS>,
public BackActionInterface<SwitchScreenAction<SettingsMenu>>, public BackActionInterface<SwitchScreenAction<SettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
ModesSettingsMenu() ModesSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTMODESETTIGNS>, SwitchScreenAction<DefaultModeSettingsMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTMODESETTIGNS>, SwitchScreenAction<DefaultModeSettingsMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMATMODESETTINGS>, SwitchScreenAction<TempomatModeSettingsMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMATMODESETTINGS>, SwitchScreenAction<TempomatModeSettingsMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_LARSMMODESETTINGS>, SwitchScreenAction<LarsmModeSettingsMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LARSMMODESETTINGS>, SwitchScreenAction<LarsmModeSettingsMenu>>>();
#ifdef FEATURE_GAMETRAK #ifdef FEATURE_GAMETRAK
constructItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAKMODESETTINGS>, SwitchScreenAction<GametrakModeSettingsMenu>>>(); constructItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAKMODESETTINGS>, SwitchScreenAction<GametrakModeSettingsMenu>>>();
#endif #endif
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

4
src/displays/menus/mosfetsmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/toggleboolaction.h" #include "actions/toggleboolaction.h"
@@ -34,8 +33,7 @@ using Mosfet2Accessor = GPIOAccessor<PINS_MOSFET2>;
class MosfetsMenu : class MosfetsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_MOSFETS>, public StaticText<TEXT_MOSFETS>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>
public ContainerMenuDefinition
{ {
public: public:
MosfetsMenu() MosfetsMenu()

22
src/displays/menus/motorfeedbackdebugmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
@@ -22,21 +21,20 @@ template<const char *Ttext, typename Ttexts, template<int> class ColorInterface>
class MotorFeedbackDebugMenu : class MotorFeedbackDebugMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<Ttext>, public StaticText<Ttext>,
public BackActionInterface<SwitchScreenAction<DebugMenu>>, public BackActionInterface<SwitchScreenAction<DebugMenu>>
public ContainerMenuDefinition
{ {
public: public:
MotorFeedbackDebugMenu() MotorFeedbackDebugMenu()
{ {
constructItem<makeComponent<MenuItem, typename Ttexts::AngleText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::AngleText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::SpeedText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::SpeedText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::SpeedKmhText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::SpeedKmhText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::ErrorText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::ErrorText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::CurrentText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::CurrentText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::CurrentFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::CurrentFixedText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::ChopsText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::ChopsText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::HallText, ColorInterface<TFT_DARKGREY>, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::HallText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };

24
src/displays/menus/motorstatedebugmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
@@ -21,22 +20,21 @@ template<const char *Ttext, typename Ttexts>
class MotorStateDebugMenu : class MotorStateDebugMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<Ttext>, public StaticText<Ttext>,
public BackActionInterface<SwitchScreenAction<DebugMenu>>, public BackActionInterface<SwitchScreenAction<DebugMenu>>
public ContainerMenuDefinition
{ {
public: public:
MotorStateDebugMenu() MotorStateDebugMenu()
{ {
constructItem<makeComponent<MenuItem, typename Ttexts::EnableText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::EnableText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::PwmText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::PwmText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::CtrlTypText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::CtrlTypText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::CtrlModText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::CtrlModText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::IMotMaxText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::IMotMaxText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::IDcMaxText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::IDcMaxText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::NMotMaxText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::NMotMaxText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::FieldWeakMaxText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::FieldWeakMaxText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, typename Ttexts::PhaseAdvMaxText, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, typename Ttexts::PhaseAdvMaxText, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };

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

@@ -3,7 +3,6 @@
// local includes // local includes
#include "actioninterface.h" #include "actioninterface.h"
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/multiaction.h" #include "actions/multiaction.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
@@ -77,24 +76,23 @@ public:
class PresetsMenu : class PresetsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_PRESETS>, public StaticText<TEXT_PRESETS>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>
public ContainerMenuDefinition
{ {
public: public:
PresetsMenu() PresetsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>, MultiAction<ApplySettingsPresetAction<&presets::defaultSettings>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>, MultiAction<ApplySettingsPresetAction<&presets::defaultSettings>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>, MultiAction<ApplyLimitsPresetAction<&presets::defaultLimits>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>, MultiAction<ApplyLimitsPresetAction<&presets::defaultLimits>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>, MultiAction<ApplyLimitsPresetAction<&presets::kidsLimits>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>, MultiAction<ApplyLimitsPresetAction<&presets::kidsLimits>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETSOFFCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::mosfetsOffControllerHardware>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETSOFFCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::mosfetsOffControllerHardware>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SPINNERCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::spinnerControllerHardware>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SPINNERCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::spinnerControllerHardware>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTBOARDCOMPUTERHARDWARE>, MultiAction<ApplyBoardcomputerHardwarePresetAction<&presets::defaultBoardcomputerHardware>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTBOARDCOMPUTERHARDWARE>, MultiAction<ApplyBoardcomputerHardwarePresetAction<&presets::defaultBoardcomputerHardware>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTDEFAULTMODE>, MultiAction<ApplyDefaultModePresetAction<&presets::defaultDefaultMode>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTDEFAULTMODE>, MultiAction<ApplyDefaultModePresetAction<&presets::defaultDefaultMode>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_SINUSOIDALDEFAULTMODE>, MultiAction<ApplyDefaultModePresetAction<&presets::sinusoidalDefaultMode>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SINUSOIDALDEFAULTMODE>, MultiAction<ApplyDefaultModePresetAction<&presets::sinusoidalDefaultMode>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTTEMPOMATMODE>, MultiAction<ApplyTempomatModePresetAction<&presets::defaultTempomatMode>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTTEMPOMATMODE>, MultiAction<ApplyTempomatModePresetAction<&presets::defaultTempomatMode>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLARSMMODE>, MultiAction<ApplyLarsmModePresetAction<&presets::defaultLarsmMode>, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLARSMMODE>, MultiAction<ApplyLarsmModePresetAction<&presets::defaultLarsmMode>, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

14
src/displays/menus/profilesmenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "actions/switchprofileaction.h" #include "actions/switchprofileaction.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
#include "icons/back.h" #include "icons/back.h"
@@ -17,17 +16,16 @@ namespace {
class ProfilesMenu : class ProfilesMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_PROFILES>, public StaticText<TEXT_PROFILES>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>
public ContainerMenuDefinition
{ {
public: public:
ProfilesMenu() ProfilesMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE0>, SwitchProfileAction<0>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE0>, SwitchProfileAction<0>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE1>, SwitchProfileAction<1>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE1>, SwitchProfileAction<1>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE2>, SwitchProfileAction<2>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE2>, SwitchProfileAction<2>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE3>, SwitchProfileAction<3>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILE3>, SwitchProfileAction<3>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

12
src/displays/menus/selectmodemenu.h
View File

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/multiaction.h" #include "actions/multiaction.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
@@ -37,21 +36,20 @@ using SetGametrakModeAction = SetterAction<ModeInterface*, currentMode, Gametrak
class SelectModeMenu : class SelectModeMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_SELECTMODE>, public StaticText<TEXT_SELECTMODE>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>
public ContainerMenuDefinition
{ {
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
SelectModeMenu() SelectModeMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULT>, MultiAction<SetDefaultModeAction, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULT>, MultiAction<SetDefaultModeAction, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMAT>, MultiAction<SetTempomatModeAction, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMAT>, MultiAction<SetTempomatModeAction, SwitchScreenAction<MainMenu>>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_LARSM>, MultiAction<SetLarsmModeAction, SwitchScreenAction<MainMenu>>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LARSM>, MultiAction<SetLarsmModeAction, SwitchScreenAction<MainMenu>>>>();
#ifdef FEATURE_GAMETRAK #ifdef FEATURE_GAMETRAK
constructItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAK>, MultiAction<SetGametrakModeAction, SwitchScreenAction<MainMenu>>>>(); constructItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAK>, MultiAction<SetGametrakModeAction, SwitchScreenAction<MainMenu>>>>();
#endif #endif
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
void start() override; void start() override;

28
src/displays/menus/settingsmenu.h
View File

@@ -5,7 +5,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/toggleboolaction.h" #include "actions/toggleboolaction.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
@@ -42,28 +41,27 @@ struct BackLedAccessor : public RefAccessor<bool> { bool &getRef() const overrid
class SettingsMenu : class SettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_SETTINGS>, public StaticText<TEXT_SETTINGS>,
public BackActionInterface<SwitchScreenAction<MainMenu>>, public BackActionInterface<SwitchScreenAction<MainMenu>>
public ContainerMenuDefinition
{ {
public: public:
SettingsMenu() SettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_LIMITSSETTINGS>, SwitchScreenAction<LimitsSettingsMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LIMITSSETTINGS>, SwitchScreenAction<LimitsSettingsMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISETTINGS>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::wifi>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISETTINGS>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::wifi>>>();
#ifdef FEATURE_BLUETOOTH #ifdef FEATURE_BLUETOOTH
constructItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHSETTINGS>, SwitchScreenAction<BluetoothSettingsMenu>, StaticMenuItemIcon<&icons::bluetooth>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLUETOOTHSETTINGS>, SwitchScreenAction<BluetoothSettingsMenu>, StaticMenuItemIcon<&icons::bluetooth>>>();
#endif #endif
constructItem<makeComponent<MenuItem, StaticText<TEXT_MODESSETTINGS>, SwitchScreenAction<ModesSettingsMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODESSETTINGS>, SwitchScreenAction<ModesSettingsMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_CONTROLLERHARDWARESETTINGS>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::hardware>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONTROLLERHARDWARESETTINGS>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::hardware>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::hardware>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::hardware>>>();
#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS) #if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
constructItem<makeComponent<MenuItem, StaticText<TEXT_AUTOCONNECTBMS>, ToggleBoolAction, CheckboxIcon, AutoConnectBmsAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOCONNECTBMS>, ToggleBoolAction, CheckboxIcon, AutoConnectBmsAccessor>>();
#endif #endif
constructItem<makeComponent<MenuItem, StaticText<TEXT_BUZZER>, SwitchScreenAction<BuzzerMenu>, StaticMenuItemIcon<&icons::buzzer>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BUZZER>, SwitchScreenAction<BuzzerMenu>, StaticMenuItemIcon<&icons::buzzer>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLED>, ToggleBoolAction, CheckboxIcon, FrontLedAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_FRONTLED>, ToggleBoolAction, CheckboxIcon, FrontLedAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACKLED>, ToggleBoolAction, CheckboxIcon, BackLedAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACKLED>, ToggleBoolAction, CheckboxIcon, BackLedAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_ABOUT>, SwitchScreenAction<AboutMenu>, StaticMenuItemIcon<&icons::info>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ABOUT>, SwitchScreenAction<AboutMenu>, StaticMenuItemIcon<&icons::info>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

48
src/displays/menus/stationwifisettingsmenu.h
View File

@@ -5,7 +5,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "menuitem.h" #include "menuitem.h"
#include "actions/dummyaction.h" #include "actions/dummyaction.h"
@@ -29,34 +28,33 @@ namespace {
class StationWifiSettingsMenu : class StationWifiSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_STATIONWIFISETTINGS>, public StaticText<TEXT_STATIONWIFISETTINGS>,
public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>, public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
StationWifiSettingsMenu() StationWifiSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFIRECONNECT>, WifiReconnectAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIRECONNECT>, WifiReconnectAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFIDISCONNECT>, WifiDisconnectAction>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIDISCONNECT>, WifiDisconnectAction>>();
constructItem<makeComponent<MenuItem, WifiIsConnectedText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiIsConnectedText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTOCONNECT>, ToggleBoolAction, CheckboxIcon, WifiAutoConnectAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTOCONNECT>, ToggleBoolAction, CheckboxIcon, WifiAutoConnectAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTORECONNECT>, ToggleBoolAction, CheckboxIcon, WifiAutoReconnectAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTORECONNECT>, ToggleBoolAction, CheckboxIcon, WifiAutoReconnectAccessor>>();
constructItem<makeComponent<MenuItem, WifiLocalIpText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiLocalIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiMacAddressText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiMacAddressText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiSubnetMaskText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSubnetMaskText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiGatewayIpText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiGatewayIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiDnsIpText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiDnsIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiBroadcastIpText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiBroadcastIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiNetworkIdText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiNetworkIdText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiSubnetCIDRText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSubnetCIDRText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFIENABLEIPV6>, WifiEnableIpV6Action>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIENABLEIPV6>, WifiEnableIpV6Action>>();
constructItem<makeComponent<MenuItem, WifiLocalIpV6Text, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiLocalIpV6Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiHostnameText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiHostnameText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiStatusText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiStatusText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiSsidText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiSsidText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiPskText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiPskText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiBssidText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiBssidText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, WifiRssiText, StaticFont<2>, DisabledColor, DummyAction>>(); constructMenuItem<makeComponent<MenuItem, WifiRssiText, StaticFont<2>, DisabledColor, DummyAction>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

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

@@ -2,7 +2,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "menuitem.h" #include "menuitem.h"
@@ -29,14 +28,13 @@ using TempomatModeModelModeChangeScreen = makeComponent<
class TempomatModeSettingsMenu : class TempomatModeSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_TEMPOMATMODESETTINGS>, public StaticText<TEXT_TEMPOMATMODESETTINGS>,
public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>, public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
TempomatModeSettingsMenu() TempomatModeSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<TempomatModeModelModeChangeScreen>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETMODELMODE>, SwitchScreenAction<TempomatModeModelModeChangeScreen>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

16
src/displays/menus/timersmenu.h
View File

@@ -3,7 +3,6 @@
// local includes // local includes
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
#include "icons/back.h" #include "icons/back.h"
@@ -61,18 +60,17 @@ using DisplayRedrawRateChangeDisplay = makeComponent<
class TimersMenu : class TimersMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_TIMERS>, public StaticText<TEXT_TIMERS>,
public BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>, public BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
TimersMenu() TimersMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_POTIREADRATE>, SwitchScreenAction<PotiReadRateChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIREADRATE>, SwitchScreenAction<PotiReadRateChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_MODEUPDATERATE>, SwitchScreenAction<ModeUpdateRateChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODEUPDATERATE>, SwitchScreenAction<ModeUpdateRateChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_STATSUPDATERATE>, SwitchScreenAction<StatsUpdateRateChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATSUPDATERATE>, SwitchScreenAction<StatsUpdateRateChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYUPDATERATE>, SwitchScreenAction<DisplayUpdateRateChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYUPDATERATE>, SwitchScreenAction<DisplayUpdateRateChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYREDRAWRATE>, SwitchScreenAction<DisplayRedrawRateChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYREDRAWRATE>, SwitchScreenAction<DisplayRedrawRateChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

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

@@ -6,7 +6,6 @@
// local includes // local includes
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/multiaction.h" #include "actions/multiaction.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
@@ -21,11 +20,13 @@ class WifiSettingsMenu;
} // namespace } // namespace
namespace { namespace {
class WifiScanMenu : public MenuDisplay, public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>, public ContainerMenuDefinition class WifiScanMenu : public MenuDisplay, public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
{ {
using Base = MenuDisplay; using Base = MenuDisplay;
public: public:
WifiScanMenu();
String text() const override; String text() const override;
void start() override; void start() override;
@@ -38,9 +39,14 @@ private:
std::vector<std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>>> m_reusableItems; std::vector<std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>>> m_reusableItems;
}; };
WifiScanMenu::WifiScanMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
String WifiScanMenu::text() const String WifiScanMenu::text() const
{ {
auto text = String{size()-1} + " found"; auto text = String{menuItemCount()-1} + " found";
switch (WiFi.scanComplete()) switch (WiFi.scanComplete())
{ {
case WIFI_SCAN_RUNNING: text += " (scanning)"; break; case WIFI_SCAN_RUNNING: text += " (scanning)"; break;
@@ -51,8 +57,6 @@ String WifiScanMenu::text() const
void WifiScanMenu::start() void WifiScanMenu::start()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
Base::start(); Base::start();
m_lastScanComplete = 0; m_lastScanComplete = 0;
@@ -68,16 +72,16 @@ void WifiScanMenu::update()
const auto now = millis(); const auto now = millis();
if (!m_lastScanComplete) if (!m_lastScanComplete)
{ {
auto backButton = takeLast(); auto backButton = takeLastMenuItem();
for (std::size_t i = 0; i < n; i++) for (std::size_t i = 0; i < n; i++)
{ {
const auto ssid = WiFi.SSID(i); const auto ssid = WiFi.SSID(i);
if (size() <= i) if (menuItemCount() <= i)
{ {
if (m_reusableItems.empty()) if (m_reusableItems.empty())
{ {
auto &item = constructItem<makeComponent<MenuItem, ChangeableText, DummyAction>>(); auto &item = constructMenuItem<makeComponent<MenuItem, ChangeableText, DummyAction>>();
item.setTitle(ssid); item.setTitle(ssid);
} }
else else
@@ -85,7 +89,7 @@ void WifiScanMenu::update()
std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>> ptr = std::move(m_reusableItems.back()); std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>> ptr = std::move(m_reusableItems.back());
m_reusableItems.pop_back(); m_reusableItems.pop_back();
ptr->setTitle(ssid); ptr->setTitle(ssid);
emplaceItem(std::move(ptr)); emplaceMenuItem(std::move(ptr));
} }
} }
else else
@@ -95,10 +99,10 @@ void WifiScanMenu::update()
} }
} }
while (size() > n) while (menuItemCount() > n)
m_reusableItems.emplace_back((makeComponent<MenuItem, ChangeableText, DummyAction>*)takeLast().release()); m_reusableItems.emplace_back((makeComponent<MenuItem, ChangeableText, DummyAction>*)takeLastMenuItem().release());
emplaceItem(std::move(backButton)); emplaceMenuItem(std::move(backButton));
m_lastScanComplete = now; m_lastScanComplete = now;
} }

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

@@ -3,7 +3,6 @@
// local includes // local includes
#include "changevaluedisplay.h" #include "changevaluedisplay.h"
#include "menudisplay.h" #include "menudisplay.h"
#include "containermenudefinition.h"
#include "utils.h" #include "utils.h"
#include "actions/switchscreenaction.h" #include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h" #include "actions/toggleboolaction.h"
@@ -36,19 +35,18 @@ using AutoWifiModeChangeDisplay = makeComponent<
class WifiSettingsMenu : class WifiSettingsMenu :
public MenuDisplay, public MenuDisplay,
public StaticText<TEXT_WIFISETTINGS>, public StaticText<TEXT_WIFISETTINGS>,
public BackActionInterface<SwitchScreenAction<SettingsMenu>>, public BackActionInterface<SwitchScreenAction<SettingsMenu>>
public ContainerMenuDefinition
{ {
public: public:
WifiSettingsMenu() WifiSettingsMenu()
{ {
constructItem<makeComponent<MenuItem, StaticText<TEXT_AUTOWIFIMODE>, SwitchScreenAction<AutoWifiModeChangeDisplay>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOWIFIMODE>, SwitchScreenAction<AutoWifiModeChangeDisplay>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_AUTOENABLEAP>, ToggleBoolAction, CheckboxIcon, AutoEnableApAccessor>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_AUTOENABLEAP>, ToggleBoolAction, CheckboxIcon, AutoEnableApAccessor>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_GENERICWIFISETTINGS>, SwitchScreenAction<GenericWifiSettingsMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GENERICWIFISETTINGS>, SwitchScreenAction<GenericWifiSettingsMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_STATIONWIFISETTINGS>, SwitchScreenAction<StationWifiSettingsMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATIONWIFISETTINGS>, SwitchScreenAction<StationWifiSettingsMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_WIFISCAN>, SwitchScreenAction<WifiScanMenu>, StaticMenuItemIcon<&icons::scan>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISCAN>, SwitchScreenAction<WifiScanMenu>, StaticMenuItemIcon<&icons::scan>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_ACCESSPOINTWIFISETTINGS>, SwitchScreenAction<AccessPointWifiSettingsMenu>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ACCESSPOINTWIFISETTINGS>, SwitchScreenAction<AccessPointWifiSettingsMenu>>>();
constructItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>(); constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
} }
}; };
} // namespace } // namespace

2
src/displays/updatedisplay.h
View File

@@ -18,7 +18,7 @@ class StatusDisplay;
} }
namespace { namespace {
#ifdef FEATURE_OTA #ifdef FEATURE_ARDUINOOTA
class UpdateDisplay : public Display, public DummyBack class UpdateDisplay : public Display, public DummyBack
{ {
public: public:

2
src/icons/logo.h
View File

@@ -4,6 +4,7 @@
namespace { namespace {
namespace icons { namespace icons {
/*
const Icon<240, 130> logo{{ const Icon<240, 130> logo{{
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0010 (16) pixels 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0010 (16) pixels
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0020 (32) pixels 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x0020 (32) pixels
@@ -1956,5 +1957,6 @@ const Icon<240, 130> logo{{
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x79D0 (31184) pixels 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x79D0 (31184) pixels
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x79E0 (31200) pixels 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // 0x79E0 (31200) pixels
}}; }};
*/
} }
} }

37
src/main.cpp
View File

@@ -88,16 +88,28 @@ millis_t lastDisplayUpdate{};
millis_t lastDisplayRedraw{}; millis_t lastDisplayRedraw{};
} }
void printMemoryStats(const char *s)
{
Serial.printf("MEMORY %s 8bit: %u 32bit: %u\r\n",
s,
heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT),
heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_32BIT));
}
void setup() void setup()
{ {
Serial.begin(115200); Serial.begin(115200);
Serial.setDebugOutput(true); Serial.setDebugOutput(true);
Serial.println("setup()"); //Serial.println("setup()");
printMemoryStats("setup()");
pinMode(3, INPUT_PULLUP); pinMode(3, INPUT_PULLUP);
currentlyReverseBeeping = false; currentlyReverseBeeping = false;
initScreen(); initScreen();
printMemoryStats("initScreen()");
#ifdef FEATURE_DPAD #ifdef FEATURE_DPAD
bootLabel.redraw("dpad"); bootLabel.redraw("dpad");
@@ -140,9 +152,11 @@ void setup()
loadSettings(); loadSettings();
} }
} }
printMemoryStats("loadSettings()");
bootLabel.redraw("swap front back"); bootLabel.redraw("swap front back");
updateSwapFrontBack(); updateSwapFrontBack();
printMemoryStats("swapFronBack()");
bootLabel.redraw("deviceName"); bootLabel.redraw("deviceName");
{ {
@@ -150,39 +164,47 @@ void setup()
WiFi.macAddress(&macAddress[0]); WiFi.macAddress(&macAddress[0]);
std::sprintf(deviceName, STRING(DEVICE_PREFIX) "_%02hhx%02hhx%02hhx", macAddress[3], macAddress[4], macAddress[5]); std::sprintf(deviceName, STRING(DEVICE_PREFIX) "_%02hhx%02hhx%02hhx", macAddress[3], macAddress[4], macAddress[5]);
} }
printMemoryStats("deviceName");
bootLabel.redraw("setHostname"); bootLabel.redraw("setHostname");
if (!WiFi.setHostname(deviceName)) if (!WiFi.setHostname(deviceName))
Serial.println("Could not setHostname"); Serial.println("Could not setHostname");
printMemoryStats("setHostname()");
bootLabel.redraw("softAPsetHostname"); bootLabel.redraw("softAPsetHostname");
if (!WiFi.softAPsetHostname(deviceName)) if (!WiFi.softAPsetHostname(deviceName))
Serial.println("Could not softAPsetHostname"); Serial.println("Could not softAPsetHostname");
printMemoryStats("softAPsetHostname()");
bootLabel.redraw("WiFi mode"); bootLabel.redraw("WiFi mode");
if (!WiFi.mode(settings.wifiSettings.autoWifiMode)) if (!WiFi.mode(settings.wifiSettings.autoWifiMode))
Serial.println("Could not set mode to WIFI_AP_STA"); Serial.println("Could not set mode to WIFI_AP_STA");
printMemoryStats("WiFi.mode()");
if (settings.wifiSettings.autoEnableAp) if (settings.wifiSettings.autoEnableAp)
{ {
bootLabel.redraw("WiFi softAp"); bootLabel.redraw("WiFi softAp");
WifiSoftApAction{}.triggered(); WifiSoftApAction{}.triggered();
} }
printMemoryStats("WifiSoftApAction()");
bootLabel.redraw("WiFi begin"); bootLabel.redraw("WiFi begin");
if (!WiFi.begin("realraum", "r3alraum")) if (!WiFi.begin("realraum", "r3alraum"))
Serial.println("Could not begin WiFi"); Serial.println("Could not begin WiFi");
printMemoryStats("WiFi.begin()");
#ifdef FEATURE_BLUETOOTH #ifdef FEATURE_BLUETOOTH
if (settings.bluetoothSettings.autoBluetoothMode == BluetoothMode::Master) if (settings.bluetoothSettings.autoBluetoothMode == BluetoothMode::Master)
{ {
bootLabel.redraw("bluetooth begin master"); bootLabel.redraw("bluetooth begin master");
BluetoothBeginMasterAction{}.triggered(); BluetoothBeginMasterAction{}.triggered();
printMemoryStats("BluetoothBeginMasterAction()");
#ifdef FEATURE_BMS #ifdef FEATURE_BMS
if (settings.autoConnectBms) if (settings.autoConnectBms)
{ {
bootLabel.redraw("connect BMS"); bootLabel.redraw("connect BMS");
BluetoothConnectBmsAction{}.triggered(); BluetoothConnectBmsAction{}.triggered();
printMemoryStats("BluetoothConnectBmsAction()");
} }
#endif #endif
} }
@@ -190,6 +212,7 @@ void setup()
{ {
bootLabel.redraw("bluetooth begin"); bootLabel.redraw("bluetooth begin");
BluetoothBeginAction{}.triggered(); BluetoothBeginAction{}.triggered();
printMemoryStats("BluetoothBeginAction()");
} }
#endif #endif
@@ -209,16 +232,19 @@ void setup()
currentMode = &modes::defaultMode; currentMode = &modes::defaultMode;
#ifdef FEATURE_OTA #ifdef FEATURE_ARDUINOOTA
bootLabel.redraw("ota"); bootLabel.redraw("ota");
initOta(); initOta();
printMemoryStats("initOta()");
#endif #endif
bootLabel.redraw("webserver"); bootLabel.redraw("webserver");
initWebserver(); initWebserver();
printMemoryStats("initWebserver()");
bootLabel.redraw("potis"); bootLabel.redraw("potis");
readPotis(); readPotis();
printMemoryStats("readPotis()");
#if defined(FEATURE_DPAD_5WIRESW) && defined(DPAD_5WIRESW_DEBUG) #if defined(FEATURE_DPAD_5WIRESW) && defined(DPAD_5WIRESW_DEBUG)
switchScreen<DPad5WireDebugDisplay>(); switchScreen<DPad5WireDebugDisplay>();
@@ -229,10 +255,15 @@ void setup()
switchScreen<CalibrateDisplay>(true); switchScreen<CalibrateDisplay>(true);
else else
switchScreen<StatusDisplay>(); switchScreen<StatusDisplay>();
printMemoryStats("switchScreen()");
} }
void loop() void loop()
{ {
//Serial.println("loop()");
//printMemoryStats("loop()");
const auto now = millis(); const auto now = millis();
#ifdef FEATURE_DPAD #ifdef FEATURE_DPAD
@@ -306,7 +337,7 @@ void loop()
handleSerial(); handleSerial();
#ifdef FEATURE_OTA #ifdef FEATURE_ARDUINOOTA
handleOta(); handleOta();
#endif #endif

19
src/menudefinitioninterface.h
View File

@@ -1,19 +0,0 @@
#pragma once
#include <utility>
#include "menuitem.h"
namespace {
class MenuDefinitionInterface
{
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(const MenuItem&)> &&callback) const = 0;
};
}

67
src/menudisplay.h
View File

@@ -8,11 +8,10 @@
#include "textinterface.h" #include "textinterface.h"
#include "widgets/label.h" #include "widgets/label.h"
#include "globals.h" #include "globals.h"
#include "menudefinitioninterface.h"
#include "menuitem.h" #include "menuitem.h"
namespace { namespace {
class MenuDisplay : public Display, public virtual TextInterface, public virtual MenuDefinitionInterface class MenuDisplay : public Display, public virtual TextInterface
{ {
public: public:
void start() override; void start() override;
@@ -32,6 +31,66 @@ public:
int selectedIndex() const { return m_selectedIndex; } int selectedIndex() const { return m_selectedIndex; }
std::size_t menuItemCount() const { return m_menuItems.size(); }
MenuItem& getMenuItem(std::size_t index)
{
if (index < m_menuItems.size())
return *m_menuItems[index].get();
throw "aua";
}
const MenuItem& getMenuItem(std::size_t index) const
{
if (index < m_menuItems.size())
return *m_menuItems[index].get();
throw "aua";
}
void runForEveryMenuItem(std::function<void(MenuItem&)> &&callback)
{
for (const auto &ptr : m_menuItems)
callback(*ptr);
}
void runForEveryMenuItem(std::function<void(const MenuItem&)> &&callback) const
{
for (const auto &ptr : m_menuItems)
callback(*ptr);
}
template<typename T, typename... Args>
T &constructMenuItem(Args&&... args)
{
auto ptr = std::make_unique<T>(std::forward<Args>(args)...);
T &ref = *ptr;
emplaceMenuItem(std::move(ptr));
return ref;
}
void emplaceMenuItem(std::unique_ptr<MenuItem> &&ptr)
{
m_menuItems.emplace_back(std::move(ptr));
}
void clearMenuItems()
{
m_menuItems.clear();
}
std::unique_ptr<MenuItem> takeLastMenuItem()
{
if (m_menuItems.empty())
throw "aua";
std::unique_ptr<MenuItem> ptr = std::move(m_menuItems.back());
m_menuItems.pop_back();
return ptr;
}
protected: protected:
void setSelectedIndex(int selectedIndex) { m_selectedIndex = selectedIndex; } void setSelectedIndex(int selectedIndex) { m_selectedIndex = selectedIndex; }
@@ -65,6 +124,8 @@ private:
int m_rotateOffset; int m_rotateOffset;
bool m_pressed; bool m_pressed;
std::vector<std::unique_ptr<MenuItem>> m_menuItems;
}; };
void MenuDisplay::start() void MenuDisplay::start()
@@ -102,7 +163,7 @@ void MenuDisplay::update()
const auto offset = m_rotateOffset; const auto offset = m_rotateOffset;
m_rotateOffset = 0; m_rotateOffset = 0;
const auto itemCount = size(); const auto itemCount = menuItemCount();
if (itemCount) if (itemCount)
{ {

21
src/ota.h
View File

@@ -1,14 +1,15 @@
#pragma once #pragma once
#ifdef FEATURE_OTA #ifdef FEATURE_ARDUINOOTA
#include <ArduinoOTA.h> #include <ArduinoOTA.h>
#endif #endif
#include "screens.h" #include "screens.h"
#include "globals.h"
#include "displays/updatedisplay.h" #include "displays/updatedisplay.h"
namespace { namespace {
#ifdef FEATURE_OTA #ifdef FEATURE_ARDUINOOTA
void initOta() void initOta()
{ {
ArduinoOTA ArduinoOTA
@@ -24,18 +25,18 @@ void initOta()
switchScreenImpl<UpdateDisplay>("Updating " + type); switchScreenImpl<UpdateDisplay>("Updating " + type);
}) })
.onEnd([]() { .onEnd([]() {
getRefByType<UpdateDisplay>().m_finished = true; ((UpdateDisplay*)currentDisplay.get())->m_finished = true;
getRefByType<UpdateDisplay>().redraw(); ((UpdateDisplay*)currentDisplay.get())->redraw();
}) })
.onProgress([](unsigned int progress, unsigned int total) { .onProgress([](unsigned int progress, unsigned int total) {
getRefByType<UpdateDisplay>().m_progress = progress; ((UpdateDisplay*)currentDisplay.get())->m_progress = progress;
getRefByType<UpdateDisplay>().m_total = total; ((UpdateDisplay*)currentDisplay.get())->m_total = total;
getRefByType<UpdateDisplay>().redraw(); ((UpdateDisplay*)currentDisplay.get())->redraw();
}) })
.onError([](ota_error_t error) { .onError([](ota_error_t error) {
getRefByType<UpdateDisplay>().m_error = error; ((UpdateDisplay*)currentDisplay.get())->m_error = error;
getRefByType<UpdateDisplay>().m_errorValid = true; ((UpdateDisplay*)currentDisplay.get())->m_errorValid = true;
getRefByType<UpdateDisplay>().redraw(); ((UpdateDisplay*)currentDisplay.get())->redraw();
}); });
ArduinoOTA.begin(); ArduinoOTA.begin();

2
src/screens.h
View File

@@ -50,7 +50,7 @@ void initScreen()
tft.fillScreen(TFT_WHITE); tft.fillScreen(TFT_WHITE);
tft.setTextColor(TFT_BLACK, TFT_WHITE); tft.setTextColor(TFT_BLACK, TFT_WHITE);
tft.setTextFont(4); tft.setTextFont(4);
tft.pushImage(0, 40, icons::logo.WIDTH, icons::logo.HEIGHT, icons::logo.buffer); //tft.pushImage(0, 40, icons::logo.WIDTH, icons::logo.HEIGHT, icons::logo.buffer);
tft.drawString("Bobbycar-OS", 32, 200); tft.drawString("Bobbycar-OS", 32, 200);
tft.drawString("booting...", 32, 225); tft.drawString("booting...", 32, 225);
bootLabel.start(); bootLabel.start();