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

Huge refactoring

Browse Source
This commit is contained in:
0xFEEDC0DE64
2021-12-30 03:17:30 +01:00
parent d5b9c1142f
commit f099d15707
124 changed files with 1369 additions and 1561 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
main/CMakeLists.txt
View File

@ -57,7 +57,6 @@ set(headers
statistics.h
statustexthelper.h
taskmanager.h
texts.h
time_bobbycar.h
types.h
udpcloud.h
@ -292,7 +291,6 @@ set(sources
statistics.cpp
statustexthelper.cpp
taskmanager.cpp
texts.cpp
time_bobbycar.cpp
types.cpp
udpcloud.cpp

14
main/accessors/settingsaccessors.h
View File

@ -182,7 +182,19 @@ struct LedsCountAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &ge
struct CenterOffsetAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.ledstrip.centerOffset; } };
struct SmallOffsetAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.ledstrip.smallOffset; } };
struct BigOffsetAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.ledstrip.bigOffset; } };
struct DeziampereAccessor : public RefAccessorSaveSettings<int16_t> { int16_t &getRef() const override { return settings.ledstrip.deziampere; } };
struct LedStripMaxMilliampsAccessor : public NewSettingsAccessor<uint32_t> { ConfigWrapper<uint32_t> &getConfig() const override { return configs.ledStripMaxMilliamps; } };
struct LedStripMaxAmpereAccessor : public virtual espgui::AccessorInterface<float>
{
float getValue() const override
{
return configs.ledStripMaxMilliamps.value / 1000.f;
}
espgui::AccessorInterface<float>::setter_result_t setValue(float value) override
{
return configs.write_config(configs.ledStripMaxMilliamps, value * 1000);
}
};
struct EnableBeepWhenBlinkAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.ledstrip.enableBeepWhenBlink; } };
struct EnableFullBlinkAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.ledstrip.enableFullBlink; } };
struct EnableLedstripStVOAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.ledstrip.enableStVO; } };

6
main/actions/rebootaction.cpp
View File

@ -6,16 +6,12 @@
// 3rdparty lib includes
#include <tftinstance.h>
// local includes
#include "globals.h"
#include "texts.h"
void RebootAction::triggered()
{
espgui::tft.fillScreen(TFT_BLACK);
espgui::tft.setTextColor(TFT_YELLOW);
espgui::tft.drawString(TEXT_REBOOT, 5, 5, 4);
espgui::tft.drawString("Reboot", 5, 5, 4);
espgui::tft.fillRect(0, 34, espgui::tft.width(), 3, TFT_WHITE);

4
main/actions/rebootaction.h
View File

@ -1,9 +1,7 @@
#pragma once
// 3rdparty lib includes
#include "actioninterface.h"
using namespace espgui;
#include <actioninterface.h>
class RebootAction : public virtual espgui::ActionInterface
{

1
main/changevaluedisplay_bluetoothmode.h
View File

@ -7,7 +7,6 @@
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
#include "texts.h"
#ifdef FEATURE_BLUETOOTH
#include "bluetoothmode.h"
#endif

4
main/displays/calibratedisplay.cpp
View File

@ -10,6 +10,10 @@
#include "displays/menus/boardcomputerhardwaresettingsmenu.h"
#include "newsettings.h"
namespace {
constexpr char TEXT_CALIBRATE[] = "Calibrate";
} // namespace
CalibrateDisplay::CalibrateDisplay(bool bootup) :
m_bootup{bootup}
{

1
main/displays/calibratedisplay.h
View File

@ -15,7 +15,6 @@
#include "bobbydisplaywithtitle.h"
#include "globals.h"
#include "utils.h"
#include "texts.h"
#include "modes/ignoreinputmode.h"
class CalibrateDisplay : public BobbyDisplayWithTitle

85
main/displays/calibratevoltagedisplay.cpp
View File

@ -1,14 +1,35 @@
#include "calibratevoltagedisplay.h"
// 3rdparty lib includes
#include <menuitem.h>
#include <icons/back.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <widgets/label.h>
#include <fmt/core.h>
// local includes
// Local includes
#include "utils.h"
#include "icons/settings.h"
#include "battery.h"
#include "menus/batterymenu.h"
#include "globals.h"
#include "displays/menus/batterymenu.h"
#include "accessors/settingsaccessors.h"
#include "bobbycheckbox.h"
namespace {
constexpr char TEXT_BATTERY_CALIBRATE[] = "Calibrate Voltages";
constexpr char TEXT_VOLTAGECALIBRATION_30V[] = "Calibrate 30.0V";
constexpr char TEXT_VOLTAGECALIBRATION_50V[] = "Calibrate 50.0V";
constexpr char TEXT_VOLTAGECALIBRATION_VALUE_30_FRONT[] = "30V Front";
constexpr char TEXT_VOLTAGECALIBRATION_VALUE_30_BACK[] = "30V Back";
constexpr char TEXT_VOLTAGECALIBRATION_VALUE_50_FRONT[] = "50V Front";
constexpr char TEXT_VOLTAGECALIBRATION_VALUE_50_BACK[] = "50V Back";
constexpr char TEXT_BATTERY_APPLYCALIB[] = "Apply calibration";
constexpr char TEXT_VOLTAGECALIBRATION_RESET[] = "Reset calibration";
constexpr char TEXT_BACK[] = "Back";
class Save30VCalibrationAction : public virtual espgui::ActionInterface
{
public:
@ -49,17 +70,58 @@ float convertToFloat(int16_t value)
return value/100.;
}
class BatteryVoltageCalibrationFront30VText : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("30V Front: {}", convertToFloat(settings.battery.front30VoltCalibration)); } };
class BatteryVoltageCalibrationBack30VText : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("30V Back: {}", convertToFloat(settings.battery.back30VoltCalibration)); } };
class BatteryVoltageCalibrationFront50VText : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("50V Front: {}", convertToFloat(settings.battery.front50VoltCalibration)); } };
class BatteryVoltageCalibrationBack50VText : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("50V Back: {}", convertToFloat(settings.battery.back50VoltCalibration)); } };
class BatteryVoltageCalibratedText : public virtual espgui::TextInterface { public: std::string text() const override { if (settings.battery.applyCalibration) return fmt::format("F{:.2f}V B{:.2f}", controllers.front.getCalibratedVoltage(), controllers.back.getCalibratedVoltage()); else return "Not activated"; } };
} // namespace
class BatteryVoltageCalibrationFront30VText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return fmt::format("30V Front: {}", convertToFloat(settings.battery.front30VoltCalibration));
}
};
using namespace espgui;
class BatteryVoltageCalibrationBack30VText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return fmt::format("30V Back: {}", convertToFloat(settings.battery.back30VoltCalibration));
}
};
class BatteryVoltageCalibrationFront50VText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return fmt::format("50V Front: {}", convertToFloat(settings.battery.front50VoltCalibration));
}
};
class BatteryVoltageCalibrationBack50VText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return fmt::format("50V Back: {}", convertToFloat(settings.battery.back50VoltCalibration));
}
};
class BatteryVoltageCalibratedText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
if (settings.battery.applyCalibration)
return fmt::format("F{:.2f}V B{:.2f}", controllers.front.getCalibratedVoltage(), controllers.back.getCalibratedVoltage());
else
return "Not activated";
}
};
} // namespace
CalibrateVoltageDisplay::CalibrateVoltageDisplay()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGECALIBRATION_30V>, Save30VCalibrationAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGECALIBRATION_50V>, Save50VCalibrationAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_APPLYCALIB>, BobbyCheckbox, BatteryApplyCalibrationAccessor>>();
@ -75,7 +137,12 @@ CalibrateVoltageDisplay::CalibrateVoltageDisplay()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VOLTAGECALIBRATION_RESET>, ResetCalibrationAction>>();
}
std::string CalibrateVoltageDisplay::text() const
{
return TEXT_BATTERY_CALIBRATE;
}
void CalibrateVoltageDisplay::back()
{
switchScreen<BatteryMenu>();
espgui::switchScreen<BatteryMenu>();
}

21
main/displays/calibratevoltagedisplay.h
View File

@ -1,27 +1,14 @@
#pragma once
// 3rdparty lib includes
#include <menuitem.h>
#include <icons/back.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <widgets/label.h>
// Local includes
// local includes
#include "bobbymenudisplay.h"
#include "utils.h"
#include "icons/settings.h"
#include "texts.h"
#include "battery.h"
#include "menus/batterymenu.h"
#include "globals.h"
class CalibrateVoltageDisplay :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_BATTERY_CALIBRATE>
class CalibrateVoltageDisplay : public BobbyMenuDisplay
{
public:
CalibrateVoltageDisplay();
std::string text() const override;
void back() override;
};

1
main/displays/gametrakcalibratedisplay.h
View File

@ -12,7 +12,6 @@
// local includes
#include "bobbydisplay.h"
#include "globals.h"
#include "texts.h"
#include "modes/ignoreinputmode.h"
namespace {

3
main/displays/ledstripcolorsdisplay.cpp
View File

@ -17,13 +17,14 @@
#include "utils.h"
#include "icons/back.h"
#include "icons/bobbycar.h"
#include "texts.h"
#include "actions/dummyaction.h"
#include "globals.h"
#include "displays/menus/ledstripmenu.h"
#ifdef FEATURE_LEDSTRIP
namespace {
constexpr char TEXT_LEDSTRIPCOLORMENU[] = "Customize Ledstrip";
int8_t selected_side = 7;
int8_t selected_color;
bool state_select_color{false};

3
main/displays/lockscreen.cpp
View File

@ -7,7 +7,6 @@
// local includes
#include "globals.h"
#include "utils.h"
#include "texts.h"
#include "displays/menus/mainmenu.h"
#include "displays/calibratedisplay.h"
#include "bobbybuttons.h"
@ -40,7 +39,7 @@ void Lockscreen::initScreen()
espgui::tft.setTextFont(4);
espgui::tft.setTextColor(TFT_YELLOW);
espgui::tft.drawString(TEXT_LOCKVEHICLE, 5, 5);
espgui::tft.drawString("Lock vehicle", 5, 5);
espgui::tft.fillRect(0, 34, espgui::tft.width(), 3, TFT_WHITE);

13
main/displays/menus/aboutmenu.cpp
View File

@ -15,6 +15,9 @@
#endif
namespace {
constexpr char TEXT_ABOUT[] = "About";
constexpr char TEXT_BACK[] = "Back";
class CurrentVersionText : public virtual espgui::TextInterface
{
public:
@ -33,10 +36,9 @@ public:
constexpr char TEXT_VERSION[] = "Version: 1.0";
} // namespace
using namespace espgui;
AboutMenu::AboutMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, CurrentVersionText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapTotal8Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapFree8Text, StaticFont<2>, DisabledColor, DummyAction>>();
@ -63,7 +65,12 @@ AboutMenu::AboutMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string AboutMenu::text() const
{
return TEXT_ABOUT;
}
void AboutMenu::back()
{
switchScreen<SettingsMenu>();
espgui::switchScreen<SettingsMenu>();
}

7
main/displays/menus/aboutmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class AboutMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_ABOUT>
class AboutMenu : public BobbyMenuDisplay
{
public:
AboutMenu();
std::string text() const override;
void back() override;
};

72
main/displays/menus/batterydebugmenu.cpp
View File

@ -1,16 +1,55 @@
#include "batterydebugmenu.h"
// 3rdparty lib includes
#include <menuitem.h>
#include <icons/back.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <fmt/core.h>
// local includes
#include "debugmenu.h"
#include "accessors/settingsaccessors.h"
#include "fmt/core.h"
#include "utils.h"
#include "icons/settings.h"
#include "battery.h"
class CurrentBatteryStatusText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryPercentageString(); } };
class CurrentAdvancedBatteryPercentageText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryAdvancedPercentageString(); } };
namespace {
constexpr char TEXT_BATTERYDEBUG[] = "Bat Debug Menu";
constexpr char TEXT_BACK[] = "Back";
class BatteryDebugText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryDebugString(); } };
class BatteryDebug2Text : public virtual espgui::TextInterface {
public: std::string text() const override {
class CurrentBatteryStatusText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return getBatteryPercentageString();
}
};
class CurrentAdvancedBatteryPercentageText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return getBatteryAdvancedPercentageString();
}
};
class BatteryDebugText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return getBatteryDebugString();
}
};
class BatteryDebug2Text : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
float avgVoltage = 0;
for (auto &controller : controllers)
{
@ -23,12 +62,22 @@ class BatteryDebug2Text : public virtual espgui::TextInterface {
return fmt::format("{:.0f} {:.0f}W/kmh", avgSpeedKmh, w_per_kmh);
}
};
class BatteryDebug3Text : public virtual espgui::TextInterface { public: std::string text() const override { return fmt::format("{}fA {}bA", fixCurrent(controllers.front.feedback.left.dcLink + controllers.front.feedback.right.dcLink), fixCurrent(controllers.back.feedback.left.dcLink + controllers.back.feedback.right.dcLink)); } };
using namespace espgui;
class BatteryDebug3Text : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return fmt::format("{}fA {}bA",
fixCurrent(controllers.front.feedback.left.dcLink + controllers.front.feedback.right.dcLink),
fixCurrent(controllers.back.feedback.left.dcLink + controllers.back.feedback.right.dcLink));
}
};
} // namespace
BatteryDebugMenu::BatteryDebugMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, CurrentBatteryStatusText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, BatteryDebugText, DisabledColor, DummyAction>>();
@ -38,7 +87,12 @@ BatteryDebugMenu::BatteryDebugMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string BatteryDebugMenu::text() const
{
return TEXT_BATTERYDEBUG;
}
void BatteryDebugMenu::back()
{
switchScreen<DebugMenu>();
espgui::switchScreen<DebugMenu>();
}

16
main/displays/menus/batterydebugmenu.h
View File

@ -1,24 +1,14 @@
#pragma once
// 3rdparty lib includes
#include <menuitem.h>
#include <icons/back.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
// Local includes
#include "displays/bobbymenudisplay.h"
#include "utils.h"
#include "icons/settings.h"
#include "texts.h"
#include "battery.h"
class BatteryDebugMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_BATTERYDEBUG>
class BatteryDebugMenu : public BobbyMenuDisplay
{
public:
BatteryDebugMenu();
std::string text() const override;
void back() override;
};

63
main/displays/menus/batterymenu.cpp
View File

@ -1,17 +1,42 @@
#include "batterymenu.h"
// 3rdparty lib includes
#include <menuitem.h>
#include <icons/back.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <changevaluedisplay.h>
#include <textwithvaluehelper.h>
#include <fmt/core.h>
// local includes
// Local includes
#include "utils.h"
#include "icons/settings.h"
#include "battery.h"
#include "selectbatterytypemenu.h"
#include "displays/bobbychangevaluedisplay.h"
#include "mainmenu.h"
#include "displays/calibratevoltagedisplay.h"
#include "accessors/settingsaccessors.h"
#include "battery.h"
namespace {
constexpr char TEXT_BATTERY[] = "Battery";
constexpr char TEXT_CELL_SERIES[] = "Cells (Series)";
constexpr char TEXT_CELL_PARALLEL[] = "Cells (Parallel)";
constexpr char TEXT_SELECT_CELL_TYPE[] = "Select Cell Type";
constexpr char TEXT_CELL_TYPE[] = "Cell Type";
constexpr char TEXT_BATTERY_CALIBRATE[] = "Calibrate Voltages";
constexpr char TEXT_BATTERY_TYPE_22P[] = "22P cells";
constexpr char TEXT_BATTERY_TYPE_HG2[] = "HG2 cells";
constexpr char TEXT_BATTERY_TYPE_MH1[] = "MH1 cells";
constexpr char TEXT_BATTERY_TYPE_VTC5[] = "VTC5 cells";
constexpr char TEXT_BATTERY_TYPE_BAK_25R[] = "BAK / 25R cells";
constexpr char TEXT_BATTERY_WHKM[] = "Wh per km";
constexpr char TEXT_BATTERY_APPLYCALIB[] = "Apply calibration";
constexpr char TEXT_VOLTAGECALIBRATION_RESET[] = "Reset calibration";
constexpr char TEXT_BACK[] = "Back";
class CurrentBatteryStatusText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryPercentageString(); } };
using BatteryCellSeriesChangeScreen = espgui::makeComponent<
@ -37,8 +62,27 @@ using BatteryWHperKMChangeScreen = espgui::makeComponent<
espgui::ConfirmActionInterface<espgui::SwitchScreenAction<BatteryMenu>>,
espgui::BackActionInterface<espgui::SwitchScreenAction<BatteryMenu>>
>;
} // namespace
using namespace espgui;
BatteryMenu::BatteryMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, CurrentBatteryStatusText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CELL_SERIES, BatterySeriesCellsAccessor>, SwitchScreenAction<BatteryCellSeriesChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CELL_PARALLEL, BatteryParallelCellsAccessor>, SwitchScreenAction<BatteryCellParallelChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_BATTERY_WHKM, BatteryWHperKMAccessor>, SwitchScreenAction<BatteryWHperKMChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECT_CELL_TYPE>, SwitchScreenAction<BatteryTypeMenu>>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_CALIBRATE>, SwitchScreenAction<CalibrateVoltageDisplay>, StaticMenuItemIcon<&bobbyicons::settings>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string BatteryMenu::text() const
{
return TEXT_BATTERY;
}
void BatteryMenu::start()
{
@ -61,20 +105,7 @@ void BatteryMenu::redraw()
m_doubleProgressBarBatPercentage.redraw(batPercent, battery::bootBatPercentage);
}
BatteryMenu::BatteryMenu()
{
constructMenuItem<makeComponent<MenuItem, CurrentBatteryStatusText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CELL_SERIES, BatterySeriesCellsAccessor>, SwitchScreenAction<BatteryCellSeriesChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CELL_PARALLEL, BatteryParallelCellsAccessor>, SwitchScreenAction<BatteryCellParallelChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_BATTERY_WHKM, BatteryWHperKMAccessor>, SwitchScreenAction<BatteryWHperKMChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECT_CELL_TYPE>, SwitchScreenAction<BatteryTypeMenu>>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_CALIBRATE>, SwitchScreenAction<CalibrateVoltageDisplay>, StaticMenuItemIcon<&bobbyicons::settings>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void BatteryMenu::back()
{
switchScreen<MainMenu>();
espgui::switchScreen<MainMenu>();
}

20
main/displays/menus/batterymenu.h
View File

@ -1,32 +1,22 @@
#pragma once
// 3rdparty lib includes
#include <menuitem.h>
#include <icons/back.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
// Local includes
// local includes
#include "displays/bobbymenudisplay.h"
#include "utils.h"
#include "icons/settings.h"
#include "texts.h"
#include "battery.h"
#include "selectbatterytypemenu.h"
#include "widgets/doubleprogressbar.h"
class BatteryMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_BATTERY>
class BatteryMenu : public BobbyMenuDisplay
{
using Base = BobbyMenuDisplay;
public:
BatteryMenu();
std::string text() const override;
void start() override;
void redraw() override;
void back() override;
private:
bobbygui::DoubleProgressBar m_doubleProgressBarBatPercentage{75, 68, 90, 24, 0, 100, TFT_RED, TFT_GREEN};
};

16
main/displays/menus/blesettingsmenu.cpp
View File

@ -10,22 +10,30 @@
#include "bletexthelpers.h"
#include "displays/menus/settingsmenu.h"
#include "bobbycheckbox.h"
#include "texts.h"
#ifdef FEATURE_BLE
using namespace espgui;
namespace {
constexpr char TEXT_BLESETTINGS[] = "BLE settings";
constexpr char TEXT_BLEENABLED[] = "BLE enabled";
constexpr char TEXT_BACK[] = "Back";
} // namespace
BleSettingsMenu::BleSettingsMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BLEENABLED>, BobbyCheckbox, BleEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, BleServerPeerDevicesText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, BleCharacSubscribedText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string BleSettingsMenu::text() const
{
return TEXT_BLESETTINGS;
}
void BleSettingsMenu::back()
{
switchScreen<SettingsMenu>();
espgui::switchScreen<SettingsMenu>();
}
#endif

8
main/displays/menus/blesettingsmenu.h
View File

@ -2,16 +2,16 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#ifdef FEATURE_BLE
class BleSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_BLESETTINGS>
class BleSettingsMenu : public BobbyMenuDisplay
{
public:
BleSettingsMenu();
std::string text() const override;
void back() override;
};
#endif

1
main/displays/menus/bluetoothsettingsmenu.h
View File

@ -19,7 +19,6 @@
#include "bluetoothtexthelpers.h"
#include "accessors/settingsaccessors.h"
#include "icons/back.h"
#include "texts.h"
using namespace espgui;
using namespace bluetoothtexthelpers;

1
main/displays/menus/bmsmenu.cpp
View File

@ -13,7 +13,6 @@
#include "actions/switchscreenaction.h"
#include "bluetoothtexthelpers.h"
#include "icons/back.h"
#include "texts.h"
#include "displays/menus/mainmenu.h"
using namespace espgui;

7
main/displays/menus/bmsmenu.h
View File

@ -3,14 +3,13 @@
#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class BmsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_BMS>
class BmsMenu : public BobbyMenuDisplay
{
public:
BmsMenu();
std::string text() const override { return TEXT_BMS; }
void back() override;
};
#endif

24
main/displays/menus/boardcomputerhardwaresettingsmenu.cpp
View File

@ -19,6 +19,25 @@
#include "displays/menus/settingsmenu.h"
namespace {
constexpr char TEXT_BOARDCOMPUTERHARDWARESETTINGS[] = "Boardcomputer H/W settings";
constexpr char TEXT_LOCKSCREENSETTINGS[] = "Lockscreen Settings";
constexpr char TEXT_CALIBRATE[] = "Calibrate";
constexpr char TEXT_SAMPLECOUNT[] = "sampleCount";
constexpr char TEXT_GASMIN[] = "gasMin";
constexpr char TEXT_GASMAX[] = "gasMax";
constexpr char TEXT_BREMSMIN[] = "bremsMin";
constexpr char TEXT_BREMSMAX[] = "bremsMax";
constexpr char TEXT_DPADDEBOUNCE[] = "dpadDebounce";
constexpr char TEXT_GAMETRAKCALIBRATE[] = "Gametrak calibrate";
constexpr char TEXT_SETGAMETRAKXMIN[] = "Set gametrakXMin";
constexpr char TEXT_SETGAMETRAKXMAX[] = "Set gametrakXMax";
constexpr char TEXT_SETGAMETRAKYMIN[] = "Set gametrakYMin";
constexpr char TEXT_SETGAMETRAKYMAX[] = "Set gametrakYMax";
constexpr char TEXT_SETGAMETRAKDISTMIN[] = "Set gametrakDistMin";
constexpr char TEXT_SETGAMETRAKDISTMAX[] = "Set gametrakDistMax";
constexpr char TEXT_TIMERS[] = "Timers";
constexpr char TEXT_BACK[] = "Back";
struct GasText : public virtual espgui::TextInterface
{
public:
@ -181,6 +200,11 @@ BoardcomputerHardwareSettingsMenu::BoardcomputerHardwareSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
std::string BoardcomputerHardwareSettingsMenu::text() const
{
return TEXT_BOARDCOMPUTERHARDWARESETTINGS;
}
void BoardcomputerHardwareSettingsMenu::back()
{
switchScreen<SettingsMenu>();

7
main/displays/menus/boardcomputerhardwaresettingsmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class BoardcomputerHardwareSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_BOARDCOMPUTERHARDWARESETTINGS>
class BoardcomputerHardwareSettingsMenu : public BobbyMenuDisplay
{
public:
BoardcomputerHardwareSettingsMenu();
std::string text() const override;
void back() override;
};

17
main/displays/menus/buzzermenu.cpp
View File

@ -15,6 +15,18 @@
#include "bobbycheckbox.h"
namespace {
constexpr char TEXT_BUZZER[] = "Buzzer";
constexpr char TEXT_FRONTFREQ[] = "Front freq";
constexpr char TEXT_FRONTPATTERN[] = "Front pattern";
constexpr char TEXT_BACKFREQ[] = "Back freq";
constexpr char TEXT_BACKPATTERN[] = "Back pattern";
constexpr char TEXT_REVERSEBEEP[] = "Reverse beep";
constexpr char TEXT_REVERSEBEEPFREQ0[] = "Reverse beep freq0";
constexpr char TEXT_REVERSEBEEPFREQ1[] = "Reverse beep freq1";
constexpr char TEXT_REVERSEBEEPDURATION0[] = "Reverse beep duration0";
constexpr char TEXT_REVERSEBEEPDURATION1[] = "Reverse beep duration1";
constexpr char TEXT_BACK[] = "Back";
struct FrontFreqAccessor : public espgui::RefAccessor<uint8_t> { uint8_t &getRef() const override { return controllers.front.command.buzzer.freq; } };
using FrontFreqChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<uint8_t>,
@ -97,6 +109,11 @@ BuzzerMenu::BuzzerMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string BuzzerMenu::text() const
{
return TEXT_BUZZER;
}
void BuzzerMenu::back()
{
switchScreen<SettingsMenu>();

7
main/displays/menus/buzzermenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class BuzzerMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_BUZZER>
class BuzzerMenu : public BobbyMenuDisplay
{
public:
BuzzerMenu();
std::string text() const override;
void back() override;
};

11
main/displays/menus/cloudsettingsmenu.cpp
View File

@ -18,6 +18,12 @@
#ifdef FEATURE_CLOUD
namespace {
constexpr char TEXT_CLOUDSETTINGS[] = "Cloud settings";
constexpr char TEXT_CLOUDENABLED[] = "Cloud enabled";
constexpr char TEXT_CLOUDTRANSMITTIMEOUT[] = "Transmit timeout";
constexpr char TEXT_CLOUDCOLLECTRATE[] = "Cloud collect rate";
constexpr char TEXT_CLOUDSENDRATE[] = "Cloud send rate";
constexpr char TEXT_BACK[] = "Back";
using CloudTransmitTimeoutChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<int16_t>,
@ -68,6 +74,11 @@ CloudSettingsMenu::CloudSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string CloudSettingsMenu::text() const
{
return TEXT_CLOUDSETTINGS;
}
void CloudSettingsMenu::back()
{
switchScreen<SettingsMenu>();

7
main/displays/menus/cloudsettingsmenu.h
View File

@ -2,16 +2,15 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#ifdef FEATURE_CLOUD
class CloudSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_CLOUDSETTINGS>
class CloudSettingsMenu : public BobbyMenuDisplay
{
public:
CloudSettingsMenu();
std::string text() const override;
void back() override;
};
#endif

6
main/displays/menus/commanddebugmenu.h
View File

@ -26,10 +26,12 @@ public:
constructMenuItem<makeComponent<MenuItem, typename Ttexts::LedText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
private:
static constexpr char TEXT_BACK[] = "Back";
};
constexpr char TEXT_FRONTCOMMAND[] = "Front command";
using FrontCommandDebugMenu = CommandDebugMenu<TEXT_FRONTCOMMAND, FrontTexts>;
constexpr char TEXT_BACKCOMMAND[] = "Back command";
using FrontCommandDebugMenu = CommandDebugMenu<TEXT_FRONTCOMMAND, FrontTexts>;
using BackCommandDebugMenu = CommandDebugMenu<TEXT_BACKCOMMAND, BackTexts>;

25
main/displays/menus/controllerhardwaresettingsmenu.cpp
View File

@ -19,6 +19,21 @@
#include "bobbycheckbox.h"
namespace {
constexpr char TEXT_CONTROLLERHARDWARESETTINGS[] = "Controller H/W settings";
constexpr char TEXT_WHEELDIAMETERMM[] = "Wheel diameter (mm)";
constexpr char TEXT_WHEELDIAMETERINCH[] = "Wheel diameter (inch)";
constexpr char TEXT_NUMMAGNETPOLES[] = "Num magnet poles";
constexpr char TEXT_SETENABLED[] = "Set enabled";
constexpr char TEXT_SETINVERTED[] = "Set inverted";
constexpr char TEXT_SWAPFRONTBACK[] = "Swap front/back";
#ifdef FEATURE_CAN
constexpr char TEXT_FRONTSENDCAN[] = "Front send CAN";
constexpr char TEXT_BACKSENDCAN[] = "Back send CAN";
constexpr char TEXT_CANTRANSMITTIMEOUT[] = "CanTransmitTimeout";
constexpr char TEXT_CANRECEIVETIMEOUT[] = "CanReceiveTimeout";
#endif
constexpr char TEXT_BACK[] = "Back";
using WheelDiameterMmChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<int16_t>,
espgui::StaticText<TEXT_WHEELDIAMETERMM>,
@ -59,10 +74,9 @@ using CanReceiveTimeoutChangeScreen = espgui::makeComponent<
#endif
} // namespace
using namespace espgui;
ControllerHardwareSettingsMenu::ControllerHardwareSettingsMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETENABLED>, SwitchScreenAction<EnableMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETINVERTED>, SwitchScreenAction<InvertMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WHEELDIAMETERMM>, SwitchScreenAction<WheelDiameterMmChangeScreen>>>();
@ -78,7 +92,12 @@ ControllerHardwareSettingsMenu::ControllerHardwareSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string ControllerHardwareSettingsMenu::text() const
{
return TEXT_CONTROLLERHARDWARESETTINGS;
}
void ControllerHardwareSettingsMenu::back()
{
switchScreen<SettingsMenu>();
espgui::switchScreen<SettingsMenu>();
}

7
main/displays/menus/controllerhardwaresettingsmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class ControllerHardwareSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_CONTROLLERHARDWARESETTINGS>
class ControllerHardwareSettingsMenu : public BobbyMenuDisplay
{
public:
ControllerHardwareSettingsMenu();
std::string text() const override;
void back() override;
};

21
main/displays/menus/crashmenu.cpp
View File

@ -1,20 +1,35 @@
#include "crashmenu.h"
// 3rdparty lib includes
#include "actions/switchscreenaction.h"
#include "icons/back.h"
// local includes
#include "actions/assertaction.h"
#include "actions/dividebyzeroaction.h"
#include "actions/switchscreenaction.h"
#include "displays/menus/settingsmenu.h"
#include "icons/back.h"
namespace {
constexpr char TEXT_CRASHMENU[] = "Crash Menu";
constexpr char TEXT_CRASH_ASSERT[] = "assert(0)";
constexpr char TEXT_CRASH_DIVZERO[] = "42 / 0";
constexpr char TEXT_BACK[] = "Back";
} // namespace
CrashMenu::CrashMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CRASH_ASSERT>, AssertAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CRASH_DIVZERO>, DivideByZeroAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string CrashMenu::text() const
{
return TEXT_CRASHMENU;
}
void CrashMenu::back()
{
switchScreen<SettingsMenu>();
espgui::switchScreen<SettingsMenu>();
}

10
main/displays/menus/crashmenu.h
View File

@ -2,15 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
using namespace espgui;
class CrashMenu :
public BobbyMenuDisplay,
public StaticText<TEXT_CRASHMENU>
class CrashMenu : public BobbyMenuDisplay
{
public:
CrashMenu();
std::string text() const override;
void back() override;
};

13
main/displays/menus/debugmenu.cpp
View File

@ -29,7 +29,11 @@
#include "bobbycheckbox.h"
namespace {
//constexpr char TEXT_DEBUG[] = "Debug";
constexpr char TEXT_DEBUG[] = "Debug";
constexpr char TEXT_TASKMANAGER[] = "Taskmanager";
constexpr char TEXT_QRCODE_DEBUG[] = "QR Debug";
constexpr char TEXT_BATTERYDEBUG[] = "Bat Debug Menu";
constexpr char TEXT_TOGGLECLOUDDEBUG[] = "Cloud Debug";
//constexpr char TEXT_FRONTCOMMAND[] = "Front command";
//constexpr char TEXT_BACKCOMMAND[] = "Back command";
//constexpr char TEXT_FRONTLEFTCOMMAND[] = "Front left command";
@ -46,7 +50,7 @@ constexpr char TEXT_LOADSETTINGS[] = "Load settings (old)";
constexpr char TEXT_SAVESETTINGS[] = "Save settings (old)";
constexpr char TEXT_ERASENVS[] = "Erase NVS (old)";
constexpr char TEXT_DYNAMICMENU[] = "GUI experiments";
//constexpr char TEXT_BACK[] = "Back";
constexpr char TEXT_BACK[] = "Back";
} // namespace
DebugMenu::DebugMenu()
@ -83,6 +87,11 @@ DebugMenu::DebugMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string DebugMenu::text() const
{
return TEXT_DEBUG;
}
void DebugMenu::back()
{
switchScreen<MainMenu>();

7
main/displays/menus/debugmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class DebugMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_DEBUG>
class DebugMenu : public BobbyMenuDisplay
{
public:
DebugMenu();
std::string text() const override;
void back() override;
};

36
main/displays/menus/defaultmodesettingsmenu.cpp
View File

@ -18,6 +18,37 @@
#include "bobbycheckbox.h"
namespace {
constexpr char TEXT_DEFAULTMODESETTIGNS[] = "Default mode settings";
constexpr char TEXT_DEFAULTMODESETTINGS[] = "Default mode settings";
constexpr char TEXT_MODELMODE[] = "Model mode";
constexpr char TEXT_HYBRIDMODE[] = "Hybrid mode";
constexpr char TEXT_SQUAREGAS[] = "Square gas";
constexpr char TEXT_SQUAREBREMS[] = "Square brems";
constexpr char TEXT_ENABLESMOOTHINGUP[] = "Enable up smoothing";
constexpr char TEXT_ENABLESMOOTHINGDOWN[] = "Enable down smoothing";
constexpr char TEXT_ENABLEFWSMOOTHINGUP[] = "Enable fw up smoothing";
constexpr char TEXT_ENABLEFWSMOOTHINGDOWN[] = "Enable fw down smoothing";
constexpr char TEXT_FWSMOOTHING_LIMIT[] = "Fw smooth lower limit";
constexpr char TEXT_SMOOTHINGVAL[] = "Smoothing";
constexpr char TEXT_FRONTPERCENTAGE[] = "Front %";
constexpr char TEXT_BACKPERCENTAGE[] = "Back %";
constexpr char TEXT_ADDSCHWELLE[] = "Add/Sub Lim";
constexpr char TEXT_SUBGASVAL[] = "Add Gas";
constexpr char TEXT_SUBBRAKEVAL[] = "Add Brake";
constexpr char TEXT_ADDGASVAL[] = "Sub Gas";
constexpr char TEXT_ADDBRAKEVAL[] = "Sub Brake";
constexpr char TEXT_HYBRIDENABLE[] = "Enable Hybrid mode";
constexpr char TEXT_HYBRIDACTIVATIONLIMIT[] = "Hybrid activation-limit";
constexpr char TEXT_HYBRIDDEACTIVATIONLIMIT[] = "Hybrid deactivation-limit";
constexpr char TEXT_LIMITS_TO_NEAR[] = "Hybrid limits too near (>20)";
constexpr char TEXT_HANDBREMSE_ENABLE[] = "Enable Handbremse";
constexpr char TEXT_HANDBREMSE_AUTOMATIC[] = "Automatic Handbremse";
constexpr char TEXT_HANDBREMSE_VISUALIZE[] = "Visualize Handbremse";
constexpr char TEXT_HANDBREMSE_MODE[] = "Handbrems Mode";
constexpr char TEXT_HANDBREMSE_TRIGGERTIMEOUT[] = "Handbrems Timeout";
constexpr char TEXT_HANDBREMSE[] = "Handbremse";
constexpr char TEXT_BACK[] = "Back";
using DefaultModeModelModeChangeDisplay = espgui::makeComponent<
BobbyChangeValueDisplay<UnifiedModelMode>,
espgui::StaticText<TEXT_MODELMODE>,
@ -141,6 +172,11 @@ DefaultModeSettingsMenu::DefaultModeSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string DefaultModeSettingsMenu::text() const
{
return TEXT_DEFAULTMODESETTIGNS;
}
void DefaultModeSettingsMenu::back()
{
switchScreen<ModesSettingsMenu>();

7
main/displays/menus/defaultmodesettingsmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class DefaultModeSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_DEFAULTMODESETTIGNS>
class DefaultModeSettingsMenu : public BobbyMenuDisplay
{
public:
DefaultModeSettingsMenu();
std::string text() const override;
void back() override;
};

17
main/displays/menus/demosmenu.cpp
View File

@ -13,10 +13,18 @@
// local includes
#include "utils.h"
using namespace espgui;
namespace {
constexpr char TEXT_DEMOS[] = "Demos";
constexpr char TEXT_STARFIELD[] = "Starfield";
constexpr char TEXT_PINGPONG[] = "PingPong";
constexpr char TEXT_SPIRO[] = "Spiro";
constexpr char TEXT_GAMEOFLIFE[] = "GameOfLife";
constexpr char TEXT_BACK[] = "Back";
} // namespace
DemosMenu::DemosMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STARFIELD>, SwitchScreenAction<StarfieldDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PINGPONG>, SwitchScreenAction<PingPongDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SPIRO>, SwitchScreenAction<SpiroDisplay>>>();
@ -24,7 +32,12 @@ DemosMenu::DemosMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string DemosMenu::text() const
{
return TEXT_DEMOS;
}
void DemosMenu::back()
{
switchScreen<MainMenu>();
espgui::switchScreen<MainMenu>();
}

7
main/displays/menus/demosmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class DemosMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_DEMOS>
class DemosMenu : public BobbyMenuDisplay
{
public:
DemosMenu();
std::string text() const override;
void back() override;
};

2
main/displays/menus/dynamicdebugmenu.cpp
View File

@ -19,7 +19,6 @@
#include "displays/bobbychangevaluedisplay.h"
#include "utils.h"
#include "icons/lock.h"
#include "texts.h"
#include "bobbycheckbox.h"
#include "bobbyerrorhandler.h"
@ -39,6 +38,7 @@ constexpr char TEXT_LOCKTOGGLE[] = "Lock toggle";
constexpr char TEXT_DEBUGTOGGLE[] = "Toggle";
constexpr char TEXT_DEBUGTOGGLEMENU[] = "Toggle (with menu)";
constexpr char TEXT_OPENPOPUP[] = "Open popup";
constexpr char TEXT_BACK[] = "Back";
bool toggleLocked{};
bool toggle{};

17
main/displays/menus/enablemenu.cpp
View File

@ -9,8 +9,18 @@
#include "accessors/settingsaccessors.h"
#include "bobbycheckbox.h"
namespace {
constexpr char TEXT_SETENABLED[] = "Set enabled";
constexpr char TEXT_ENABLEFRONTLEFT[] = "Enable front left";
constexpr char TEXT_ENABLEFRONTRIGHT[] = "Enable front right";
constexpr char TEXT_ENABLEBACKLEFT[] = "Enable back left";
constexpr char TEXT_ENABLEBACKRIGHT[] = "Enable back right";
constexpr char TEXT_BACK[] = "Back";
} // namespace
EnableMenu::EnableMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>, BobbyCheckbox, FrontLeftEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, BobbyCheckbox, FrontRightEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>, BobbyCheckbox, BackLeftEnabledAccessor>>();
@ -18,7 +28,12 @@ EnableMenu::EnableMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string EnableMenu::text() const
{
return TEXT_SETENABLED;
}
void EnableMenu::back()
{
switchScreen<ControllerHardwareSettingsMenu>();
espgui::switchScreen<ControllerHardwareSettingsMenu>();
}

10
main/displays/menus/enablemenu.h
View File

@ -2,15 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
using namespace espgui;
class EnableMenu :
public BobbyMenuDisplay,
public StaticText<TEXT_SETENABLED>
class EnableMenu : public BobbyMenuDisplay
{
public:
EnableMenu();
std::string text() const override;
void back() override;
};

58
main/displays/menus/espnowmenu.cpp
View File

@ -5,6 +5,12 @@
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
#include <accessorinterface.h>
#include <actioninterface.h>
#include <espchrono.h>
#include <fmt/core.h>
#include <menudisplay.h>
#include <textinterface.h>
// local includes
#include "icons/settings.h"
@ -12,22 +18,60 @@
#include "displays/menus/espnowsettingsmenu.h"
#include "displays/menus/settingsmenu.h"
#include "bobbycheckbox.h"
#include "espnowfunctions.h"
using namespace espgui;
namespace {
constexpr char TEXT_ESPNOW_MENU[] = "ESP-Now Menu";
constexpr char TEXT_ESPNOW_RECEIVETS[] = "Recv Ts State";
constexpr char TEXT_ESPNOW_RECEIVETSFROMBOBBY[] = "Recv BobbyTs State";
constexpr char TEXT_ESPNOW_SENDTSMSG[] = "Broadcast Time";
constexpr char TEXT_ESPNOW_SETTINGS[] = "ESP-Now settings";
constexpr char TEXT_BACK[] = "Back";
namespace espnowmenu {
struct ReceiveTimeStampAccessor : public espgui::RefAccessor<bool>
{
bool &getRef() const override
{
return espnow::receiveTimeStamp;
}
};
struct ReceiveTsFromOtherBobbycarsAccessor : public espgui::RefAccessor<bool>
{
bool &getRef() const override
{
return espnow::receiveTsFromOtherBobbycars;
}
};
class SendBobbycarTimesyncMessageAction : public virtual espgui::ActionInterface
{
public:
void triggered() override
{
const auto message = fmt::format("BOBBYT:{}", espchrono::utc_clock::now().time_since_epoch().count());
espnow::send_espnow_message(message);
}
};
} // namespace
EspNowMenu::EspNowMenu() {
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SENDTSMSG>, espnowmenu::SendBobbycarTimesyncMessageAction, StaticMenuItemIcon<&bobbyicons::time>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETS>, BobbyCheckbox, espnowmenu::ReceiveTimeStampAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETSFROMBOBBY>, BobbyCheckbox, espnowmenu::ReceiveTsFromOtherBobbycarsAccessor>>();
EspNowMenu::EspNowMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SENDTSMSG>, SendBobbycarTimesyncMessageAction, StaticMenuItemIcon<&bobbyicons::time>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETS>, BobbyCheckbox, ReceiveTimeStampAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_RECEIVETSFROMBOBBY>, BobbyCheckbox, ReceiveTsFromOtherBobbycarsAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SETTINGS>, SwitchScreenAction<EspNowSettingsMenu>, StaticMenuItemIcon<&bobbyicons::settings>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string EspNowMenu::text() const
{
return TEXT_ESPNOW_MENU;
}
void EspNowMenu::back()
{
switchScreen<SettingsMenu>();
espgui::switchScreen<SettingsMenu>();
}
#endif

35
main/displays/menus/espnowmenu.h
View File

@ -2,43 +2,16 @@
#ifdef FEATURE_ESPNOW
// 3rdparty lib includes
#include <accessorinterface.h>
#include <actioninterface.h>
#include <espchrono.h>
#include <fmt/core.h>
#include <menudisplay.h>
#include <textinterface.h>
#include <texts.h>
// local includes
#include "displays/bobbymenudisplay.h"
#include "espnowfunctions.h"
using namespace espgui;
namespace espnowmenu {
struct ReceiveTimeStampAccessor : public RefAccessor<bool> { bool &getRef() const override { return espnow::receiveTimeStamp; } };
struct ReceiveTsFromOtherBobbycarsAccessor : public RefAccessor<bool> { bool &getRef() const override { return espnow::receiveTsFromOtherBobbycars; } };
class SendBobbycarTimesyncMessageAction : public virtual ActionInterface {
public:
void triggered() override
{
const auto message = fmt::format("BOBBYT:{}", espchrono::utc_clock::now().time_since_epoch().count());
espnow::send_espnow_message(message);
}
};
} // namespace
class EspNowMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_ESPNOW_MENU>
class EspNowMenu : public BobbyMenuDisplay
{
public:
EspNowMenu();
std::string text() const override;
void back() override;
};

28
main/displays/menus/espnowsettingsmenu.cpp
View File

@ -1,31 +1,49 @@
#include "espnowsettingsmenu.h"
#ifdef FEATURE_ESPNOW
// 3rdparty lib includes
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
#include <accessorinterface.h>
#include <actioninterface.h>
#include <espchrono.h>
#include <fmt/core.h>
#include <menudisplay.h>
#include <textinterface.h>
// local includes
#include "accessors/settingsaccessors.h"
#include "icons/time.h"
#include "espnowmenu.h"
#include "bobbycheckbox.h"
#include "espnowfunctions.h"
using namespace espgui;
namespace espnowsettingsmenu {
namespace {
constexpr char TEXT_ESPNOW_SETTINGS[] = "ESP-Now settings";
constexpr char TEXT_ESPNOW_SYNCTIME[] = "Sync time (no NTP)";
constexpr char TEXT_ESPNOW_SYNCWITHOTHERS[] = "Sync time with others";
constexpr char TEXT_ESPNOW_SYNCBLINK[] = "Sync blink";
constexpr char TEXT_BACK[] = "Back";
} // namespace
EspNowSettingsMenu::EspNowSettingsMenu() {
EspNowSettingsMenu::EspNowSettingsMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCTIME>, BobbyCheckbox, ESPNowSyncTimeEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCWITHOTHERS>, BobbyCheckbox, ESPNowSyncTimeWithOthersEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW_SYNCBLINK>, BobbyCheckbox, ESPNowSyncBlinkEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<EspNowMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string EspNowSettingsMenu::text() const
{
return TEXT_ESPNOW_SETTINGS;
}
void EspNowSettingsMenu::back()
{
switchScreen<EspNowMenu>();
espgui::switchScreen<EspNowMenu>();
}
#endif

22
main/displays/menus/espnowsettingsmenu.h
View File

@ -2,30 +2,16 @@
#ifdef FEATURE_ESPNOW
// 3rdparty lib includes
#include <accessorinterface.h>
#include <actioninterface.h>
#include <espchrono.h>
#include <fmt/core.h>
#include <menudisplay.h>
#include <textinterface.h>
#include <texts.h>
// local includes
#include "displays/bobbymenudisplay.h"
#include "espnowfunctions.h"
using namespace espgui;
namespace espnowsettingsmenu {
} // namespace
class EspNowSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_ESPNOW_SETTINGS>
class EspNowSettingsMenu : public BobbyMenuDisplay
{
public:
EspNowSettingsMenu();
std::string text() const override;
void back() override;
};

3
main/displays/menus/feedbackdebugmenu.h
View File

@ -29,6 +29,9 @@ public:
constructMenuItem<makeComponent<MenuItem, typename Ttexts::TimeoutCntSerialText, StaticFont<2>, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
private:
static constexpr char TEXT_BACK[] = "Back";
};
constexpr char TEXT_FRONTFEEDBACK[] = "Front feedback";

9
main/displays/menus/gametrakmodesettingsmenu.h
View File

@ -6,15 +6,11 @@
#include "menuitem.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
#include "texts.h"
using namespace espgui;
namespace {
#ifdef FEATURE_GAMETRAK
class ContainerModeSettingsMenu :
public BobbyMenuDisplay,
public StaticText<TEXT_GAMETRAKMODESETTINGS>,
public BackActionInterface<SwitchScreenAction<ModesSettingsMenu>>
{
public:
@ -22,6 +18,11 @@ public:
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string text() const override
{
return TEXT_GAMETRAKMODESETTINGS;
}
};
#endif
} // namespace

43
main/displays/menus/garagenmenu.cpp
View File

@ -4,29 +4,66 @@
// 3rd party libs
#include <icons/back.h>
#include <menuitem.h>
#include <actioninterface.h>
#include <esp_log.h>
#include <menuitem.h>
// local includes
#include "actions/switchscreenaction.h"
#include "displays/menus/mainmenu.h"
#include "espnowfunctions.h"
#include "globals.h"
#include "newsettings.h"
using namespace espgui;
namespace {
constexpr char TEXT_GARAGE[] = "Garage";
constexpr char TEXT_BACK[] = "Back";
class SendEspNowMessageAction : public virtual espgui::ActionInterface
{
public:
SendEspNowMessageAction(uint8_t index) : m_index{index} {}
void triggered() override;
private:
uint8_t m_index;
};
} // namespace
GarageMenu::GarageMenu()
{
using namespace espgui;
for (uint8_t index = 0; index < configs.wireless_door_configs.size(); index++)
{
const auto &wirelessDoor = configs.wireless_door_configs[index];
if (wirelessDoor.doorId.value.empty() || wirelessDoor.doorToken.value.empty())
continue;
auto &menuitem = constructMenuItem<makeComponentArgs<MenuItem, garagenmenu::SendEspNowMessageAction, ChangeableText>>(index);
auto &menuitem = constructMenuItem<makeComponentArgs<MenuItem, SendEspNowMessageAction, ChangeableText>>(index);
menuitem.setTitle(wirelessDoor.doorId.value);
}
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string GarageMenu::text() const
{
return TEXT_GARAGE;
}
void GarageMenu::back()
{
switchScreen<MainMenu>();
espgui::switchScreen<MainMenu>();
}
namespace {
void SendEspNowMessageAction:: triggered()
{
if (const auto error = espnow::send_espnow_message(fmt::format("BOBBYOPEN:{}:{}", configs.wireless_door_configs[m_index].doorId.value, configs.wireless_door_configs[m_index].doorToken.value)); error != ESP_OK)
{
ESP_LOGE("BOBBY", "send_espnow_message() failed with: %s", esp_err_to_name(error));
return;
}
}
} // namespace
#endif

34
main/displays/menus/garagenmenu.h
View File

@ -1,41 +1,17 @@
#pragma once
#if defined(FEATURE_GARAGE) && defined (FEATURE_ESPNOW)
// 3rd party lib
#include <actioninterface.h>
#include <esp_log.h>
#include <menuitem.h>
// local includes
#include "displays/bobbymenudisplay.h"
#include "espnowfunctions.h"
#include "texts.h"
#include "globals.h"
#include "newsettings.h"
namespace garagenmenu {
class SendEspNowMessageAction : public virtual espgui::ActionInterface
{
public:
SendEspNowMessageAction(uint8_t index) : m_index{index} {}
void triggered() override
{
if (const auto error = espnow::send_espnow_message(fmt::format("BOBBYOPEN:{}:{}", configs.wireless_door_configs[m_index].doorId.value, configs.wireless_door_configs[m_index].doorToken.value)); error != ESP_OK)
{
ESP_LOGE("BOBBY", "send_espnow_message() failed with: %s", esp_err_to_name(error));
return;
}
}
private:
uint8_t m_index;
};
} // namespace garagenmenu
class GarageMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_GARAGE>
class GarageMenu : public BobbyMenuDisplay
{
public:
GarageMenu();
std::string text() const override;
void back() override;
};
#endif

29
main/displays/menus/graphsmenu.cpp
View File

@ -14,6 +14,24 @@
#include "displays/menus/mainmenu.h"
namespace {
constexpr char TEXT_GRAPHS[] = "Graphs";
constexpr char TEXT_GAS[] = "Gas";
constexpr char TEXT_BREMS[] = "Brems";
constexpr char TEXT_POTIS[] = "Potis";
constexpr char TEXT_AVGSPEED[] = "Avg. speed";
constexpr char TEXT_AVGSPEEDKMH[] = "Avg. speed KMH";
constexpr char TEXT_SUMCURRENT[] = "Sum current";
constexpr char TEXT_FRONTVOLTAGE[] = "Front voltage";
constexpr char TEXT_BACKVOLTAGE[] = "Back voltage";
constexpr char TEXT_VOLTAGES[] = "Voltages";
constexpr char TEXT_BMSVOLTAGE[] = "BMS voltage";
constexpr char TEXT_BMSCURRENT[] = "BMS current";
constexpr char TEXT_BMSPOWER[] = "BMS power";
constexpr char TEXT_SUMCURRENTSCOMPARISON[] = "Sum currents comparison";
constexpr char TEXT_MOTORCURRENTS[] = "Motor currents";
constexpr char TEXT_RSSI[] = "RSSI";
constexpr char TEXT_BACK[] = "Back";
using GasGraphDisplay = espgui::makeComponent<
BobbyGraphDisplay<1>,
espgui::StaticText<TEXT_GAS>,
@ -152,11 +170,9 @@ using RssiGraphDisplay = espgui::makeComponent<
>;
} // namespace
using namespace espgui;
GraphsMenu::GraphsMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAS>, SwitchScreenAction<GasGraphDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BREMS>, SwitchScreenAction<BremsGraphDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIS>, SwitchScreenAction<PotisGraphDisplay>>>();
@ -179,7 +195,12 @@ GraphsMenu::GraphsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string GraphsMenu::text() const
{
return TEXT_GRAPHS;
}
void GraphsMenu::back()
{
switchScreen<MainMenu>();
espgui::switchScreen<MainMenu>();
}

7
main/displays/menus/graphsmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class GraphsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_GRAPHS>
class GraphsMenu : public BobbyMenuDisplay
{
public:
GraphsMenu();
std::string text() const override;
void back() override;
};

19
main/displays/menus/greenpassmenu.cpp
View File

@ -18,9 +18,11 @@
#include "qrimport.h"
#include "bobbycheckbox.h"
using namespace espgui;
namespace {
constexpr char TEXT_GREENPASS[] = "Green Pass";
constexpr char TEXT_ADDCERT[] = "Add cert";
constexpr char TEXT_DELCERT[] = "Delete cert mode";
constexpr char TEXT_BACK[] = "Back";
bool deleteMode;
struct DeleteModeAccessor : espgui::RefAccessor<bool> { bool &getRef() const override { return deleteMode; } };
@ -47,11 +49,11 @@ public:
if (deleteMode)
{
qrimport::delete_qr_code(m_qrmenu.text);
switchScreen<GreenPassMenu>();
espgui::switchScreen<GreenPassMenu>();
}
else
{
switchScreen<QrDisplay>(m_qrmenu.message, m_qrmenu.ver);
espgui::switchScreen<QrDisplay>(m_qrmenu.message, m_qrmenu.ver);
}
}
private:
@ -62,6 +64,8 @@ private:
GreenPassMenu::GreenPassMenu()
{
using namespace espgui;
for (uint8_t index = 0; index < 4; index++)
{
const std::string nvs_key = fmt::format("covidcert-{}", index);
@ -87,7 +91,12 @@ GreenPassMenu::GreenPassMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string GreenPassMenu::text() const
{
return TEXT_GREENPASS;
}
void GreenPassMenu::back()
{
switchScreen<MainMenu>();
espgui::switchScreen<MainMenu>();
}

13
main/displays/menus/greenpassmenu.h
View File

@ -1,19 +1,14 @@
#pragma once
// 3rdparty lib includes
#include <accessorinterface.h>
#include <qrcode.h>
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class GreenPassMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_GREENPASS>
class GreenPassMenu : public BobbyMenuDisplay
{
public:
GreenPassMenu();
std::string text() const override;
void back() override;
};

14
main/displays/menus/handbremssettingsmenu.cpp
View File

@ -12,10 +12,17 @@
#include "accessors/settingsaccessors.h"
#include "changevaluedisplay_handbremsmode.h"
#include "displays/menus/defaultmodesettingsmenu.h"
#include "texts.h"
#include "bobbycheckbox.h"
namespace {
constexpr char TEXT_HANDBREMSE_ENABLE[] = "Enable Handbremse";
constexpr char TEXT_HANDBREMSE_AUTOMATIC[] = "Automatic Handbremse";
constexpr char TEXT_HANDBREMSE_VISUALIZE[] = "Visualize Handbremse";
constexpr char TEXT_HANDBREMSE_MODE[] = "Handbrems Mode";
constexpr char TEXT_HANDBREMSE_TRIGGERTIMEOUT[] = "Handbrems Timeout";
constexpr char TEXT_HANDBREMSE[] = "Handbremse";
constexpr char TEXT_BACK[] = "Back";
using HandBremsTriggerTimeoutChangeValueDisplay = espgui::makeComponent<
BobbyChangeValueDisplay<uint16_t>,
espgui::StaticText<TEXT_HANDBREMSE_TRIGGERTIMEOUT>,
@ -51,6 +58,11 @@ HandbremsSettingsMenu::HandbremsSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DefaultModeSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string HandbremsSettingsMenu::text() const
{
return TEXT_HANDBREMSE;
}
void HandbremsSettingsMenu::back()
{
espgui::switchScreen<DefaultModeSettingsMenu>();

8
main/displays/menus/handbremssettingsmenu.h
View File

@ -2,13 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class HandbremsSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_HANDBREMSE>
class HandbremsSettingsMenu : public BobbyMenuDisplay
{
public:
HandbremsSettingsMenu();
std::string text() const override;
void back() override;
};

13
main/displays/menus/invertmenu.cpp
View File

@ -9,6 +9,15 @@
#include "displays/menus/controllerhardwaresettingsmenu.h"
#include "bobbycheckbox.h"
namespace {
constexpr char TEXT_SETINVERTED[] = "Set inverted";
constexpr char TEXT_INVERTFRONTLEFT[] = "Invert front left";
constexpr char TEXT_INVERTFRONTRIGHT[] = "Invert front right";
constexpr char TEXT_INVERTBACKLEFT[] = "Invert back left";
constexpr char TEXT_INVERTBACKRIGHT[] = "Invert back right";
constexpr char TEXT_BACK[] = "Back";
} // namespace
InvertMenu::InvertMenu()
{
using namespace espgui;
@ -19,6 +28,10 @@ InvertMenu::InvertMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string InvertMenu::text() const
{
return TEXT_SETINVERTED;
}
void InvertMenu::back()
{

8
main/displays/menus/invertmenu.h
View File

@ -2,13 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class InvertMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_SETINVERTED>
class InvertMenu : public BobbyMenuDisplay
{
public:
InvertMenu();
std::string text() const override;
void back() override;
};

11
main/displays/menus/larsmmodesettingsmenu.cpp
View File

@ -15,6 +15,12 @@
#include "displays/menus/modessettingsmenu.h"
namespace {
constexpr char TEXT_LARSMMODESETTINGS[] = "Larsm mode settings";
constexpr char TEXT_MODELMODE[] = "Model mode";
constexpr char TEXT_SETMODE[] = "Set mode";
constexpr char TEXT_SETITERATIONS[] = "Set iterations";
constexpr char TEXT_BACK[] = "Back";
using LarsmModeModelModeChangeDisplay = espgui::makeComponent<
BobbyChangeValueDisplay<UnifiedModelMode>,
espgui::StaticText<TEXT_MODELMODE>,
@ -48,6 +54,11 @@ LarsmModeSettingsMenu::LarsmModeSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string LarsmModeSettingsMenu::text() const
{
return TEXT_LARSMMODESETTINGS;
}
void LarsmModeSettingsMenu::back()
{
switchScreen<ModesSettingsMenu>();

9
main/displays/menus/larsmmodesettingsmenu.h
View File

@ -1,17 +1,14 @@
#pragma once
// 3rdparty lib includes
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class LarsmModeSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_LARSMMODESETTINGS>
class LarsmModeSettingsMenu : public BobbyMenuDisplay
{
public:
LarsmModeSettingsMenu();
std::string text() const override;
void back() override;
};

81
main/displays/menus/ledstripmenu.cpp
View File

@ -25,6 +25,30 @@
// clang-format off
namespace {
constexpr char TEXT_LEDSTRIP[] = "Ledstrip";
constexpr char TEXT_LEDANIMATION[] = "LED Animation";
constexpr char TEXT_SELECTANIMATION[] = "Select Animation";
constexpr char TEXT_BRAKELIGHTS[] = "Brake Lights";
constexpr char TEXT_LEDSTRIPCOLORMENU[] = "Customize Ledstrip";
constexpr char TEXT_BLINKANIMATION[] = "Blink animation";
constexpr char TEXT_ANIMATION_TYPE[] = "Blink animation";
constexpr char TEXT_LEDSCOUNT[] = "LEDs Count";
constexpr char TEXT_CENTEROFFSET[] = "Center Offset";
constexpr char TEXT_SMALLOFFSET[] = "Small Offset";
constexpr char TEXT_BIGOFFSET[] = "Big Offset";
constexpr char TEXT_LEDSTRIPCURRENTLIMIT[] = "Ledstrip Currentlimit";
constexpr char TEXT_BLINKBEEP[] = "Blink Beep";
constexpr char TEXT_FULLBLINK[] = "Full blink";
constexpr char TEXT_LEDSTRIP_STVO[] = "Enable StVO";
constexpr char TEXT_STVO_FRONTOFFSET[] = "StVO Front Offset";
constexpr char TEXT_STVO_FRONTLENGTH[] = "StVO Front Length";
constexpr char TEXT_STVO_ENABLEFRONTLIGHT[] = "StVO Front Enable";
constexpr char TEXT_ANIMATION_MULTIPLIER[] = "Animation Multiplier";
constexpr char TEXT_LEDSTRIP_BRIGHTNESS[] = "Ledstrip Brightness";
constexpr char TEXT_LEDSTRIP_ALLCUSTOMOFF[] = "All custom off";
constexpr char TEXT_LEDSTRIP_CHANGE_OTA_ANIM[] = "Change Ota animation";
constexpr char TEXT_BACK[] = "Back";
using LedsCountChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<int16_t>,
espgui::StaticText<TEXT_LEDSCOUNT>,
@ -57,10 +81,11 @@ using BigOffsetChangeScreen = espgui::makeComponent<
espgui::BackActionInterface<espgui::SwitchScreenAction<LedstripMenu>>
>;
using DeziampereChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<int16_t>,
espgui::StaticText<TEXT_LEDSTRIP_MILLIAMP>,
DeziampereAccessor,
using LedStripMaxAmpereChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<float>,
espgui::StaticText<TEXT_LEDSTRIPCURRENTLIMIT>,
LedStripMaxAmpereAccessor,
espgui::RatioNumberStep<float, std::ratio<1,10>>,
espgui::ConfirmActionInterface<espgui::SwitchScreenAction<LedstripMenu>>,
espgui::BackActionInterface<espgui::SwitchScreenAction<LedstripMenu>>
>;
@ -81,7 +106,7 @@ using StVOLengthChangeScreen = espgui::makeComponent<
espgui::BackActionInterface<espgui::SwitchScreenAction<LedstripMenu>>
>;
using animationMultiplierChangeScreen = espgui::makeComponent<
using AnimationMultiplierChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<int16_t>,
espgui::StaticText<TEXT_ANIMATION_MULTIPLIER>,
AnimationMultiplierAccessor,
@ -89,7 +114,7 @@ using animationMultiplierChangeScreen = espgui::makeComponent<
espgui::BackActionInterface<espgui::SwitchScreenAction<LedstripMenu>>
>;
using ledstripBrightnessChangeScreen = espgui::makeComponent<
using LedStripBrightnessChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<uint8_t>,
espgui::StaticText<TEXT_LEDSTRIP_BRIGHTNESS>,
LedstripBrightnessAccessor,
@ -102,10 +127,16 @@ class AllCustomLedsOffAction : public virtual espgui::ActionInterface
public:
void triggered() override
{
for(int index = 0; index < 8; index++)
{
ledstrip_custom_colors[index] = CRGB{0,0,0};
}
std::fill(std::begin(ledstrip_custom_colors), std::end(ledstrip_custom_colors), CRGB{0, 0, 0});
}
};
class LedStripMaxCurrentText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return fmt::format("&sLedstrip max current: &f&2{:.02f}A", configs.ledStripMaxMilliamps.value / 1000.f);
}
};
} // namespace
@ -113,33 +144,43 @@ public:
LedstripMenu::LedstripMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIPCOLORMENU>, espgui::SwitchScreenAction<LedstripColorsDisplay>>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDANIMATION>, BobbyCheckbox, EnableLedAnimationAccessor>>();
if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_STVO>, BobbyCheckbox, EnableLedstripStVOAccessor>>(); }
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_STVO_ENABLEFRONTLIGHT>, BobbyCheckbox, EnableLedstripStVOFrontlight>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDANIMATION>, BobbyCheckbox, EnableLedAnimationAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_SELECTANIMATION>, espgui::SwitchScreenAction<LedstripSelectAnimationMenu>>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BRAKELIGHTS>, BobbyCheckbox, EnableBrakeLightsAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIPCOLORMENU>, espgui::SwitchScreenAction<LedstripColorsDisplay>>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_ALLCUSTOMOFF>, AllCustomLedsOffAction>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BLINKBEEP>, BobbyCheckbox, EnableBeepWhenBlinkAccessor>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_FULLBLINK>, BobbyCheckbox, EnableFullBlinkAccessor>>();
if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_STVO>, BobbyCheckbox, EnableLedstripStVOAccessor>>(); }
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_STVO_ENABLEFRONTLIGHT>, BobbyCheckbox, EnableLedstripStVOFrontlight>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_ALLCUSTOMOFF>, AllCustomLedsOffAction>>();
if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_STVO_FRONTOFFSET, LedsStVOFrontOffsetAccessor>, espgui::SwitchScreenAction<StVOOffsetChangeScreen>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_STVO_FRONTLENGTH, LedsStVOFrontLengthAccessor>, espgui::SwitchScreenAction<StVOLengthChangeScreen>>>(); }
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_SELECTANIMATION>, espgui::SwitchScreenAction<LedstripSelectAnimationMenu>>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BLINKANIMATION>, espgui::SwitchScreenAction<LedstripSelectBlinkMenu>>>();
#ifdef FEATURE_OTA
if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_CHANGE_OTA_ANIM>, espgui::SwitchScreenAction<ledstripOtaAnimationChangeMenu>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_CHANGE_OTA_ANIM>, espgui::SwitchScreenAction<LedstripOtaAnimationChangeMenu>>>(); }
#endif
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_ANIMATION_MULTIPLIER>, espgui::SwitchScreenAction<animationMultiplierChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_ANIMATION_MULTIPLIER>, espgui::SwitchScreenAction<AnimationMultiplierChangeScreen>>>();
if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_LEDSCOUNT, LedsCountAccessor>, espgui::SwitchScreenAction<LedsCountChangeScreen>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_CENTEROFFSET, CenterOffsetAccessor>, espgui::SwitchScreenAction<CenterOffsetChangeScreen>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_SMALLOFFSET, SmallOffsetAccessor>, espgui::SwitchScreenAction<SmallOffsetChangeScreen>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_BIGOFFSET, BigOffsetAccessor>, espgui::SwitchScreenAction<BigOffsetChangeScreen>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_BRIGHTNESS>, espgui::SwitchScreenAction<ledstripBrightnessChangeScreen>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_LEDSTRIP_MILLIAMP, DeziampereAccessor>, espgui::SwitchScreenAction<DeziampereChangeScreen>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_LEDSTRIP_BRIGHTNESS>, espgui::SwitchScreenAction<LedStripBrightnessChangeScreen>>>(); }
if (!simplified) { constructMenuItem<makeComponent<MenuItem, LedStripMaxCurrentText, espgui::SwitchScreenAction<LedStripMaxAmpereChangeScreen>>>(); }
constructMenuItem<makeComponent<MenuItem, espgui::StaticText<TEXT_BACK>, espgui::SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string LedstripMenu::text() const
{
return TEXT_LEDSTRIP;
}
void LedstripMenu::back()
{
espgui::switchScreen<MainMenu>();

7
main/displays/menus/ledstripmenu.h
View File

@ -2,16 +2,15 @@
// local includes
#include "displays/menudisplaywithtime.h"
#include "texts.h"
#ifdef FEATURE_LEDSTRIP
class LedstripMenu :
public bobbygui::MenuDisplayWithTime,
public espgui::StaticText<TEXT_LEDSTRIP>
class LedstripMenu : public bobbygui::MenuDisplayWithTime
{
public:
LedstripMenu();
std::string text() const override;
void back() override;
};
#endif

17
main/displays/menus/ledstripselectanimationmenu.cpp
View File

@ -8,10 +8,14 @@
#include "ledstripdefines.h"
#include "ledstripmenu.h"
using namespace espgui;
#ifdef FEATURE_LEDSTRIP
namespace {
constexpr char TEXT_SELECTANIMATION[] = "Select Animation";
constexpr char TEXT_ANIMATION_DEFAULTRAINBOW[] = "Default Rainbow";
constexpr char TEXT_ANIMATION_BETTERRAINBOW[] = "Better Rainbow";
constexpr char TEXT_ANIMATION_SPEEDSYNCANIMATION[] = "Speed Sync";
constexpr char TEXT_ANIMATION_CUSTOMCOLOR[] = "Custom Color";
constexpr char TEXT_BACK[] = "Back";
class CurrentSelectedAnimationText : public virtual espgui::TextInterface
{
@ -23,6 +27,8 @@ public:
LedstripSelectAnimationMenu::LedstripSelectAnimationMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, CurrentSelectedAnimationText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_DEFAULTRAINBOW>, LedStripSetAnimationAction<LedstripAnimation::DefaultRainbow>>>();
@ -32,9 +38,14 @@ LedstripSelectAnimationMenu::LedstripSelectAnimationMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<LedstripMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string LedstripSelectAnimationMenu::text() const
{
return TEXT_SELECTANIMATION;
}
void LedstripSelectAnimationMenu::back()
{
switchScreen<LedstripMenu>();
espgui::switchScreen<LedstripMenu>();
}
namespace {

8
main/displays/menus/ledstripselectanimationmenu.h
View File

@ -2,15 +2,15 @@
// Local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#ifdef FEATURE_LEDSTRIP
class LedstripSelectAnimationMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_SELECTANIMATION>
class LedstripSelectAnimationMenu : public BobbyMenuDisplay
{
public:
LedstripSelectAnimationMenu();
std::string text() const override;
void back() override;
};
#endif

75
main/displays/menus/ledstripselectblinkmenu.cpp
View File

@ -11,34 +11,31 @@
#include "accessors/settingsaccessors.h"
#include "actions/ledstripblinkactions.h"
#include "displays/menus/ledstripmenu.h"
#include "ledstrip.h"
#include "ledstripdefines.h"
#include "bobbycheckbox.h"
using namespace espgui;
namespace {
constexpr char TEXT_BLINKANIMATION[] = "Blink animation";
constexpr char TEXT_ANIMATION_BLINKNONE[] = "Blink Off";
constexpr char TEXT_ANIMATION_BLINKLEFT[] = "Blink Left";
constexpr char TEXT_ANIMATION_BLINKRIGHT[] = "Blink Right";
constexpr char TEXT_ANIMATION_BLINKBOTH[] = "Blink Both";
constexpr char TEXT_LEDSTRIP_EN_BLINK_ANIM[] = "Animated Blink";
constexpr char TEXT_BACK[] = "Back";
std::string currentSelectedBlinkAnimationText::text() const {
switch (blinkAnimation) {
case LEDSTRIP_OVERWRITE_BLINKLEFT:
#ifndef LEDSTRIP_WRONG_DIRECTION
return TEXT_ANIMATION_BLINKLEFT;
#else
return TEXT_ANIMATION_BLINKRIGHT;
#endif
case LEDSTRIP_OVERWRITE_BLINKRIGHT:
#ifndef LEDSTRIP_WRONG_DIRECTION
return TEXT_ANIMATION_BLINKRIGHT;
#else
return TEXT_ANIMATION_BLINKLEFT;
#endif
case LEDSTRIP_OVERWRITE_BLINKBOTH:
return TEXT_ANIMATION_BLINKBOTH;
default:
return TEXT_ANIMATION_BLINKNONE;
}
}
class CurrentSelectedBlinkAnimationText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
} // namespace
LedstripSelectBlinkMenu::LedstripSelectBlinkMenu()
{
constructMenuItem<makeComponent<MenuItem, currentSelectedBlinkAnimationText, DisabledColor, DummyAction>>();
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, CurrentSelectedBlinkAnimationText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_BLINKNONE>, LedstripAnimationBlinkNoneAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ANIMATION_BLINKLEFT>, LedstripAnimationBlinkLeftAction>>();
@ -48,8 +45,40 @@ LedstripSelectBlinkMenu::LedstripSelectBlinkMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<LedstripMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string LedstripSelectBlinkMenu::text() const
{
return TEXT_BLINKANIMATION;
}
void LedstripSelectBlinkMenu::back()
{
switchScreen<LedstripMenu>();
espgui::switchScreen<LedstripMenu>();
}
namespace {
std::string CurrentSelectedBlinkAnimationText::text() const
{
switch (blinkAnimation)
{
case LEDSTRIP_OVERWRITE_BLINKLEFT:
#ifndef LEDSTRIP_WRONG_DIRECTION
return TEXT_ANIMATION_BLINKLEFT;
#else
return TEXT_ANIMATION_BLINKRIGHT;
#endif
case LEDSTRIP_OVERWRITE_BLINKRIGHT:
#ifndef LEDSTRIP_WRONG_DIRECTION
return TEXT_ANIMATION_BLINKRIGHT;
#else
return TEXT_ANIMATION_BLINKLEFT;
#endif
case LEDSTRIP_OVERWRITE_BLINKBOTH:
return TEXT_ANIMATION_BLINKBOTH;
default:
return TEXT_ANIMATION_BLINKNONE;
}
}
} // namespace
#endif

14
main/displays/menus/ledstripselectblinkmenu.h
View File

@ -2,22 +2,14 @@
// Local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#include "ledstrip.h"
#include "ledstripdefines.h"
#ifdef FEATURE_LEDSTRIP
class currentSelectedBlinkAnimationText : public virtual espgui::TextInterface
{
public: std::string text() const override;
};
class LedstripSelectBlinkMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_BLINKANIMATION>
class LedstripSelectBlinkMenu : public BobbyMenuDisplay
{
public:
LedstripSelectBlinkMenu();
std::string text() const override;
void back() override;
};
#endif

39
main/displays/menus/ledstripselectotamode.cpp
View File

@ -1,24 +1,51 @@
#include "ledstripselectotamode.h"
// 3rdparty lib includes
#include "actions/switchscreenaction.h"
#include "icons/back.h"
// local includes
#include "ledstrip.h"
#include "globals.h"
#include "utils.h"
#include "ledstripmenu.h"
// Local includes
#if defined(FEATURE_LEDSTRIP) && defined(FEATURE_OTA)
using namespace espgui;
namespace {
constexpr char TEXT_BLINKANIMATION[] = "Blink animation";
constexpr char TEXT_OTAANIM_NONE[] = "None";
constexpr char TEXT_OTAANIM_PROGRESS[] = "Progress Bar";
constexpr char TEXT_OTAANIM_COLOR[] = "Color change";
constexpr char TEXT_BACK[] = "Back";
ledstripOtaAnimationChangeMenu::ledstripOtaAnimationChangeMenu()
template <OtaAnimationModes mode>
class LedstripChangeOtaAnimModeAction : public virtual espgui::ActionInterface
{
public:
void triggered() override
{
settings.ledstrip.otaMode = mode;
saveSettings();
}
};
} // namespace
LedstripOtaAnimationChangeMenu::LedstripOtaAnimationChangeMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_OTAANIM_NONE>, LedstripChangeOtaAnimModeAction<OtaAnimationModes::None>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_OTAANIM_PROGRESS>, LedstripChangeOtaAnimModeAction<OtaAnimationModes::GreenProgressBar>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_OTAANIM_COLOR>, LedstripChangeOtaAnimModeAction<OtaAnimationModes::ColorChangeAll>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<LedstripMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void ledstripOtaAnimationChangeMenu::back()
std::string LedstripOtaAnimationChangeMenu::text() const
{
switchScreen<LedstripMenu>();
return TEXT_BLINKANIMATION;
}
void LedstripOtaAnimationChangeMenu::back()
{
espgui::switchScreen<LedstripMenu>();
}
#endif

24
main/displays/menus/ledstripselectotamode.h
View File

@ -1,31 +1,15 @@
#pragma once
// Local includes
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#include "ledstrip.h"
#include "globals.h"
#include "utils.h"
#if defined(FEATURE_LEDSTRIP) && defined(FEATURE_OTA)
template <OtaAnimationModes mode>
class LedstripChangeOtaAnimModeAction : public virtual espgui::ActionInterface
class LedstripOtaAnimationChangeMenu : public BobbyMenuDisplay
{
public:
void triggered() override
{
settings.ledstrip.otaMode = mode;
saveSettings();
}
};
LedstripOtaAnimationChangeMenu();
class ledstripOtaAnimationChangeMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_BLINKANIMATION>
{
public:
ledstripOtaAnimationChangeMenu();
std::string text() const override;
void back() override;
};
#endif

14
main/displays/menus/limitssettingsmenu.cpp
View File

@ -14,6 +14,15 @@
#include "displays/menus/settingsmenu.h"
namespace {
constexpr char TEXT_LIMITSSETTINGS[] = "Limit settings";
constexpr char TEXT_IMOTMAX[] = "iMotMax";
constexpr char TEXT_IDCMAX[] = "iDcMax";
constexpr char TEXT_NMOTMAXKMH[] = "nMotMaxKmh";
constexpr char TEXT_NMOTMAX[] = "nMotMax";
constexpr char TEXT_FIELDWEAKMAX[] = "fldWkMax";
constexpr char TEXT_PHASEADVMAX[] = "phsAdvMax";
constexpr char TEXT_BACK[] = "Back";
using IMotMaxChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<int16_t>,
espgui::StaticText<TEXT_IMOTMAX>,
@ -71,6 +80,11 @@ LimitsSettingsMenu::LimitsSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string LimitsSettingsMenu::text() const
{
return TEXT_LIMITSSETTINGS;
}
void LimitsSettingsMenu::back()
{
switchScreen<SettingsMenu>();

7
main/displays/menus/limitssettingsmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class LimitsSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_LIMITSSETTINGS>
class LimitsSettingsMenu : public BobbyMenuDisplay
{
public:
LimitsSettingsMenu();
std::string text() const override;
void back() override;
};

19
main/displays/menus/lockscreensettingsmenu.cpp
View File

@ -15,6 +15,15 @@
#include "bobbycheckbox.h"
namespace {
constexpr char TEXT_LOCKSCREENSETTINGS[] = "Lockscreen Settings";
constexpr char TEXT_ALLOWPRESETSWITCH[] = "Allow preset switch";
constexpr char TEXT_KEEPLOCKED[] = "Keep locked";
constexpr char TEXT_PINDIGIT0[] = "PIN digit0";
constexpr char TEXT_PINDIGIT1[] = "PIN digit1";
constexpr char TEXT_PINDIGIT2[] = "PIN digit2";
constexpr char TEXT_PINDIGIT3[] = "PIN digit3";
constexpr char TEXT_BACK[] = "Back";
using LockscreenPinDigit0ChangeScreen = espgui::makeComponent<
BobbyChangeValueDisplay<int8_t>,
espgui::StaticText<TEXT_PINDIGIT0>,
@ -48,10 +57,9 @@ using LockscreenPinDigit3ChangeScreen = espgui::makeComponent<
>;
} // namespace
using namespace espgui;
LockscreenSettingsMenu::LockscreenSettingsMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ALLOWPRESETSWITCH>, BobbyCheckbox, LockscreenAllowPresetSwitchAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_KEEPLOCKED>, BobbyCheckbox, LockscreenKeepLockedAccessor>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_PINDIGIT0, LockscreenPinDigitAccessor<0>>, SwitchScreenAction<LockscreenPinDigit0ChangeScreen>>>();
@ -61,7 +69,12 @@ LockscreenSettingsMenu::LockscreenSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string LockscreenSettingsMenu::text() const
{
return TEXT_LOCKSCREENSETTINGS;
}
void LockscreenSettingsMenu::back()
{
switchScreen<BoardcomputerHardwareSettingsMenu>();
espgui::switchScreen<BoardcomputerHardwareSettingsMenu>();
}

7
main/displays/menus/lockscreensettingsmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class LockscreenSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_LOCKSCREENSETTINGS>
class LockscreenSettingsMenu : public BobbyMenuDisplay
{
public:
LockscreenSettingsMenu();
std::string text() const override;
void back() override;
};

80
main/displays/menus/mainmenu.cpp
View File

@ -1,5 +1,7 @@
#include "mainmenu.h"
// esp-idf includes
// 3rdparty lib includes
#include "actions/switchscreenaction.h"
#include "icons/back.h"
@ -52,23 +54,42 @@
#include "icons/time.h"
#include "tftinstance.h"
using namespace espgui;
namespace {
constexpr char TAG[] = "BOBBY";
constexpr char TEXT_MAINMENU[] = "Main menu";
constexpr char TEXT_STATUS[] = "Status";
constexpr char TEXT_LEDSTRIP[] = "Ledstrip";
constexpr char TEXT_STATISTICSMENU[] = "Statistics";
constexpr char TEXT_SELECTMODE[] = "Select mode";
constexpr char TEXT_MODESETTINGS[] = "Mode settings";
constexpr char TEXT_PRESETS[] = "Presets";
constexpr char TEXT_PROFILES[] = "Profiles";
constexpr char TEXT_GRAPHS[] = "Graphs";
constexpr char TEXT_POWERSUPPLY[] = "Powersupply";
constexpr char TEXT_BMS[] = "BMS";
constexpr char TEXT_SETTINGS[] = "Settings";
constexpr char TEXT_GREENPASS[] = "Green Pass";
constexpr char TEXT_LOCKVEHICLE[] = "Lock vehicle";
constexpr char TEXT_MOSFETS[] = "Mosfets";
constexpr char TEXT_DEMOS[] = "Demos";
constexpr char TEXT_GARAGE[] = "Garage";
constexpr char TEXT_UPDATE[] = "Update";
constexpr char TEXT_POWEROFF[] = "Poweroff";
constexpr char TEXT_REBOOT[] = "Reboot";
constexpr char TEXT_DEBUG[] = "Debug";
constexpr char TEXT_BATTERY[] = "Battery";
constexpr char TEXT_BATTERYDEBUG[] = "Bat Debug Menu";
constexpr char TEXT_TOGGLECLOUDDEBUG[] = "Cloud Debug";
namespace mainmenu {
/*
class CurrentTimeText : public virtual TextInterface
{
public:
std::string text() const override
{
return fmt::format("&7Time: {}", local_clock_string());
}
};
*/
} // namespace
MainMenu::MainMenu()
{
using namespace espgui;
ESP_LOGI(TAG, "called");
// constructMenuItem<makeComponent<MenuItem, mainmenu::CurrentTimeText, DummyAction, StaticMenuItemIcon<&bobbyicons::time>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATUS>, SwitchScreenAction<StatusDisplay>, StaticMenuItemIcon<&espgui::icons::back>>>();
#ifdef FEATURE_LEDSTRIP
@ -77,21 +98,8 @@ MainMenu::MainMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATISTICSMENU>, SwitchScreenAction<StatisticsMenu>, StaticMenuItemIcon<&bobbyicons::statistics>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECTMODE>, SwitchScreenAction<SelectModeMenu>, StaticMenuItemIcon<&bobbyicons::modes>>>();
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODESETTINGS>, ModeSettingsAction>>(); }
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PRESETS>, SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&bobbyicons::presets>>>(); }
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILES>, SwitchScreenAction<ProfilesMenu>>>(); }
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GRAPHS>, SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&bobbyicons::graph>>>(); }
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY>, SwitchScreenAction<BatteryMenu>, StaticMenuItemIcon<&bobbyicons::battery>>>(); }
#if defined(FEATURE_CAN) && defined(FEATURE_POWERSUPPLY)
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POWERSUPPLY>, SwitchScreenAction<PowerSupplyDisplay>>>(); }
#endif
#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMS>, SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&bobbyicons::bms>>>(); }
#endif
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETTINGS>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&bobbyicons::settings>>>(); }
#ifdef FEATURE_MOSFETS
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETS>, SwitchScreenAction<MosfetsMenu>>>(); }
#endif
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEMOS>, SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&bobbyicons::demos>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GREENPASS>, SwitchScreenAction<GreenPassMenu>, StaticMenuItemIcon<&bobbyicons::greenpass>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LOCKVEHICLE>, SwitchScreenAction<Lockscreen>, StaticMenuItemIcon<&bobbyicons::lock>>>();
#if defined(FEATURE_GARAGE) && defined (FEATURE_ESPNOW)
@ -100,15 +108,33 @@ MainMenu::MainMenu()
#ifdef FEATURE_OTA
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_UPDATE>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&bobbyicons::update>>>(); }
#endif
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GRAPHS>, SwitchScreenAction<GraphsMenu>, StaticMenuItemIcon<&bobbyicons::graph>>>(); }
#if defined(FEATURE_CAN) && defined(FEATURE_POWERSUPPLY)
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POWERSUPPLY>, SwitchScreenAction<PowerSupplyDisplay>>>(); }
#endif
#ifdef FEATURE_MOSFETS
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETS>, SwitchScreenAction<MosfetsMenu>>>(); }
#endif
#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BMS>, SwitchScreenAction<BmsMenu>, StaticMenuItemIcon<&bobbyicons::bms>>>(); }
#endif
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEMOS>, SwitchScreenAction<DemosMenu>, StaticMenuItemIcon<&bobbyicons::demos>>>();
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PROFILES>, SwitchScreenAction<ProfilesMenu>>>(); }
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_PRESETS>, SwitchScreenAction<PresetsMenu>, StaticMenuItemIcon<&bobbyicons::presets>>>(); }
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUG>, SwitchScreenAction<DebugMenu>>>(); }
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POWEROFF>, SwitchScreenAction<PoweroffDisplay>, StaticMenuItemIcon<&bobbyicons::poweroff>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_REBOOT>, RebootAction, StaticMenuItemIcon<&bobbyicons::reboot>>>();
if (SHOWITEM) { constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEBUG>, SwitchScreenAction<DebugMenu>>>(); }
#ifdef MAINMENU_PLUGIN
GMEN1
#endif
}
std::string MainMenu::text() const
{
return TEXT_MAINMENU;
}
void MainMenu::back()
{
switchScreen<StatusDisplay>();
espgui::switchScreen<StatusDisplay>();
}

9
main/displays/menus/mainmenu.h
View File

@ -4,7 +4,6 @@
#include "menuitem.h"
// local includes
#include "texts.h"
#include "displays/menudisplaywithtime.h"
#ifdef MAINMENU_PLUGIN
#include MAINMENU_PLUGIN
@ -21,12 +20,14 @@ namespace {
#endif
} // namespace
class MainMenu :
public bobbygui::MenuDisplayWithTime,
public espgui::StaticText<TEXT_MAINMENU>
class MainMenu : public bobbygui::MenuDisplayWithTime
{
using Base = espgui::MenuDisplay;
public:
MainMenu();
std::string text() const override;
void back() override;
};

17
main/displays/menus/modessettingsmenu.cpp
View File

@ -12,10 +12,18 @@
#include "displays/menus/gametrakmodesettingsmenu.h"
#include "displays/menus/settingsmenu.h"
using namespace espgui;
namespace {
constexpr char TEXT_MODESSETTINGS[] = "Modes settings";
constexpr char TEXT_DEFAULTMODESETTIGNS[] = "Default mode settings";
constexpr char TEXT_TEMPOMATMODESETTINGS[] = "Tempomat mode settings";
constexpr char TEXT_LARSMMODESETTINGS[] = "Larsm mode settings";
constexpr char TEXT_GAMETRAKMODESETTINGS[] = "Gametrak mode settings";
constexpr char TEXT_BACK[] = "Back";
} // namespace
ModesSettingsMenu::ModesSettingsMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTMODESETTIGNS>, SwitchScreenAction<DefaultModeSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TEMPOMATMODESETTINGS>, SwitchScreenAction<TempomatModeSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LARSMMODESETTINGS>, SwitchScreenAction<LarsmModeSettingsMenu>>>();
@ -25,7 +33,12 @@ ModesSettingsMenu::ModesSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string ModesSettingsMenu::text() const
{
return TEXT_MODESSETTINGS;
}
void ModesSettingsMenu::back()
{
switchScreen<SettingsMenu>();
espgui::switchScreen<SettingsMenu>();
}

7
main/displays/menus/modessettingsmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class ModesSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_MODESSETTINGS>
class ModesSettingsMenu : public BobbyMenuDisplay
{
public:
ModesSettingsMenu();
std::string text() const override;
void back() override;
};

30
main/displays/menus/mosfetsmenu.cpp
View File

@ -2,26 +2,52 @@
#ifdef FEATURE_MOSFETS
// 3rdparty lib includes
#include "accessorinterface.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
// local includes
#include "displays/menus/mainmenu.h"
#include "bobbycheckbox.h"
#include "types.h"
using namespace espgui;
namespace {
constexpr char TEXT_MOSFETS[] = "Mosfets";
constexpr char TEXT_MOSFET0[] = "Mosfet0";
constexpr char TEXT_MOSFET1[] = "Mosfet1";
constexpr char TEXT_MOSFET2[] = "Mosfet2";
constexpr char TEXT_BACK[] = "Back";
template<pin_t PIN>
class GPIOAccessor : public virtual espgui::AccessorInterface<bool>
{
public:
bool getValue() const override { return digitalRead(PIN); }
espgui::AccessorInterface<bool>::setter_result_t setValue(bool value) override { digitalWrite(PIN, value ? HIGH : LOW); return {}; }
};
using Mosfet0Accessor = GPIOAccessor<PINS_MOSFET0>;
using Mosfet1Accessor = GPIOAccessor<PINS_MOSFET1>;
using Mosfet2Accessor = GPIOAccessor<PINS_MOSFET2>;
} // namespace
MosfetsMenu::MosfetsMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET0>, BobbyCheckbox, Mosfet0Accessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET1>, BobbyCheckbox, Mosfet1Accessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFET2>, BobbyCheckbox, Mosfet2Accessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string MosfetsMenu::text() const
{
return TEXT_MOSFETS;
}
void MosfetsMenu::back()
{
switchScreen<MainMenu>();
espgui::switchScreen<MainMenu>();
}
#endif

23
main/displays/menus/mosfetsmenu.h
View File

@ -1,32 +1,17 @@
#pragma once
#ifdef FEATURE_MOSFETS
// 3rdparty lib includes
#include "accessorinterface.h"
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#include "types.h"
template<pin_t PIN>
class GPIOAccessor : public virtual espgui::AccessorInterface<bool>
{
public:
bool getValue() const override { return digitalRead(PIN); }
espgui::AccessorInterface<bool>::setter_result_t setValue(bool value) override { digitalWrite(PIN, value ? HIGH : LOW); return {}; }
};
using Mosfet0Accessor = GPIOAccessor<PINS_MOSFET0>;
using Mosfet1Accessor = GPIOAccessor<PINS_MOSFET1>;
using Mosfet2Accessor = GPIOAccessor<PINS_MOSFET2>;
class MosfetsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_MOSFETS>
class MosfetsMenu : public BobbyMenuDisplay
{
public:
MosfetsMenu();
std::string text() const override;
void back() override;
};
#endif

4
main/displays/menus/motorfeedbackdebugmenu.h
View File

@ -8,7 +8,6 @@
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
#include "texts.h"
#include "debugtexthelpers.h"
#include "debugcolorhelpers.h"
@ -39,6 +38,9 @@ public:
constructMenuItem<makeComponent<MenuItem, typename Ttexts::HallText, ColorInterface<TFT_DARKGREY>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
private:
static constexpr char TEXT_BACK[] = "Back";
};
constexpr char TEXT_FRONTLEFTFEEDBACK[] = "Front left feedback";

3
main/displays/menus/motorstatedebugmenu.h
View File

@ -35,6 +35,9 @@ public:
constructMenuItem<makeComponent<MenuItem, typename Ttexts::NCruiseMotTgtText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DebugMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
private:
static constexpr char TEXT_BACK[] = "Back";
};
constexpr char TEXT_FRONTLEFTCOMMAND[] = "Front left command";

10
main/displays/menus/motortestmodesettingsmenu.cpp
View File

@ -13,6 +13,11 @@
#include "displays/menus/modessettingsmenu.h"
namespace {
constexpr char TEXT_MOTORTESTMODESETTINGS[] = "Motortest mode seetings";
constexpr char TEXT_MOTORTESTMAXPWM[] = "Max Pwm";
constexpr char TEXT_MOTORTESTMULTIPLIKATOR[] = "Acceleration";
constexpr char TEXT_BACK[] = "Back";
using MotortestMultiplikatorChangeDisplay = espgui::makeComponent<
BobbyChangeValueDisplay<uint8_t>,
espgui::StaticText<TEXT_MOTORTESTMULTIPLIKATOR>,
@ -39,6 +44,11 @@ MotortestModeSettingsMenu::MotortestModeSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ModesSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string MotortestModeSettingsMenu::text() const
{
return TEXT_MOTORTESTMODESETTINGS;
}
void MotortestModeSettingsMenu::back()
{
switchScreen<ModesSettingsMenu>();

7
main/displays/menus/motortestmodesettingsmenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class MotortestModeSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_MOTORTESTMODESETTINGS>
class MotortestModeSettingsMenu : public BobbyMenuDisplay
{
public:
MotortestModeSettingsMenu();
std::string text() const override;
void back() override;
};

2
main/displays/menus/networksettingsmenu.cpp
View File

@ -19,7 +19,7 @@ using namespace espgui;
namespace {
constexpr char TEXT_STASETTINGS[] = "STA Settings";
constexpr char TEXT_APSETTINGS[] = "AP Settings";
//constexpr char TEXT_BACK[] = "Back";
constexpr char TEXT_BACK[] = "Back";
} // namespace
NetworkSettingsMenu::NetworkSettingsMenu()

18
main/displays/menus/otamenu.cpp
View File

@ -16,11 +16,18 @@
#include "displays/updatedisplay.h"
#ifdef FEATURE_OTA
using namespace espgui;
namespace {
constexpr char TEXT_UPDATE[] = "Update";
constexpr char TEXT_UPDATENOW[] = "Update now";
constexpr char TEXT_SELECTBUILD[] = "Select build";
constexpr char TEXT_SELECT_BRANCH[] = "Select Branch";
constexpr char TEXT_SELECTBUILDSERVERMENU[] = "Select Buildserver";
constexpr char TEXT_BACK[] = "Back";
} // namespace
OtaMenu::OtaMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECTBUILD>, SwitchScreenAction<SelectBuildMenu>, StaticMenuItemIcon<&bobbyicons::presets>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SELECT_BRANCH>, SwitchScreenAction<SelectBuildserverBranchMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_UPDATENOW>, SwitchScreenAction<UpdateDisplay>, StaticMenuItemIcon<&bobbyicons::update>>>();
@ -28,8 +35,13 @@ OtaMenu::OtaMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string OtaMenu::text() const
{
return TEXT_UPDATE;
}
void OtaMenu::back()
{
switchScreen<MainMenu>();
espgui::switchScreen<MainMenu>();
}
#endif

7
main/displays/menus/otamenu.h
View File

@ -2,14 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class OtaMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_UPDATE>
class OtaMenu : public BobbyMenuDisplay
{
public:
OtaMenu();
std::string text() const override;
void back() override;
};

25
main/displays/menus/presetsmenu.cpp
View File

@ -10,10 +10,28 @@
#include "menudisplay.h"
#include "presets.h"
#include "settings.h"
#include "texts.h"
#include "utils.h"
namespace {
constexpr char TEXT_PRESETS[] = "Presets";
constexpr char TEXT_DEFAULTEVERYTHING[] = "Default everything";
constexpr char TEXT_DEFAULTLIMITS[] = "Default limits";
constexpr char TEXT_KIDSLIMITS[] = "Kids limits";
constexpr char TEXT_DEFAULTPOTI[] = "Default poti";
constexpr char TEXT_DEFAULTCONTROLLERHARDWARE[] = "Default controller H/W";
constexpr char TEXT_MOSFETSOFFCONTROLLERHARDWARE[] = "MOSFETs off controller H/W";
constexpr char TEXT_SPINNERCONTROLLERHARDWARE[] = "Spinner controller H/W";
constexpr char TEXT_DEFAULTBOARDCOMPUTERHARDWARE[] = "Default boardcomputer H/W";
constexpr char TEXT_DEFAULTDEFAULTMODE[] = "Default defaultMode";
constexpr char TEXT_SINUSOIDALDEFAULTMODE[] = "Sinusoidal defaultMode";
constexpr char TEXT_DEFAULTTEMPOMATMODE[] = "Default tempomatMode";
constexpr char TEXT_DEFAULTLARSMMODE[] = "Default larsmMode";
constexpr char TEXT_STREET[] = "Street";
constexpr char TEXT_SIDEWALK[] = "Sidewalk";
constexpr char TEXT_POLICE[] = "Police";
constexpr char TEXT_RACE[] = "Race";
constexpr char TEXT_BACK[] = "Back";
class ApplyPresetAction : public virtual ActionInterface
{
public:
@ -86,6 +104,11 @@ PresetsMenu::PresetsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string PresetsMenu::text() const
{
return TEXT_PRESETS;
}
void PresetsMenu::back()
{
switchScreen<MainMenu>();

8
main/displays/menus/presetsmenu.h
View File

@ -2,13 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class PresetsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_PRESETS>
class PresetsMenu : public BobbyMenuDisplay
{
public:
PresetsMenu();
std::string text() const override;
void back() override;
};

15
main/displays/menus/profilesmenu.cpp
View File

@ -6,7 +6,15 @@
#include "displays/menus/mainmenu.h"
#include "icons/back.h"
#include "menudisplay.h"
#include "texts.h"
namespace {
constexpr char TEXT_PROFILES[] = "Profiles";
constexpr char TEXT_PROFILE0[] = "Profile 0";
constexpr char TEXT_PROFILE1[] = "Profile 1";
constexpr char TEXT_PROFILE2[] = "Profile 2";
constexpr char TEXT_PROFILE3[] = "Profile 3";
constexpr char TEXT_BACK[] = "Back";
} // namespace
ProfilesMenu::ProfilesMenu()
{
@ -17,6 +25,11 @@ ProfilesMenu::ProfilesMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string ProfilesMenu::text() const
{
return TEXT_PROFILES;
}
void ProfilesMenu::back()
{
switchScreen<MainMenu>();

8
main/displays/menus/profilesmenu.h
View File

@ -2,13 +2,13 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class ProfilesMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_PROFILES>
class ProfilesMenu : public BobbyMenuDisplay
{
public:
ProfilesMenu();
std::string text() const override;
void back() override;
};

41
main/displays/menus/selectbatterytypemenu.cpp
View File

@ -1,13 +1,44 @@
#include "selectbatterytypemenu.h"
// 3rdparty lib includes
#include <menuitem.h>
#include <icons/back.h>
#include <actions/switchscreenaction.h>
#include <actioninterface.h>
#include <actions/dummyaction.h>
// local includes
#include "battery.h"
#include "globals.h"
#include "utils.h"
#include "displays/menus/batterymenu.h"
#include "batterymenu.h"
#include "displays/menus/mainmenu.h"
namespace {
class CurrentBatteryTypeText : public virtual espgui::TextInterface { public: std::string text() const override { return getBatteryCellTypeString(); } };
constexpr char TEXT_CELL_SERIES[] = "Cells (Series)";
constexpr char TEXT_CELL_PARALLEL[] = "Cells (Parallel)";
constexpr char TEXT_SELECT_CELL_TYPE[] = "Select Cell Type";
constexpr char TEXT_CELL_TYPE[] = "Cell Type";
constexpr char TEXT_BATTERY_CALIBRATE[] = "Calibrate Voltages";
constexpr char TEXT_BATTERY_TYPE_22P[] = "22P cells";
constexpr char TEXT_BATTERY_TYPE_HG2[] = "HG2 cells";
constexpr char TEXT_BATTERY_TYPE_MH1[] = "MH1 cells";
constexpr char TEXT_BATTERY_TYPE_VTC5[] = "VTC5 cells";
constexpr char TEXT_BATTERY_TYPE_BAK_25R[] = "BAK / 25R cells";
constexpr char TEXT_BATTERY_WHKM[] = "Wh per km";
constexpr char TEXT_BATTERY_APPLYCALIB[] = "Apply calibration";
constexpr char TEXT_VOLTAGECALIBRATION_RESET[] = "Reset calibration";
constexpr char TEXT_BACK[] = "Back";
class CurrentBatteryTypeText : public virtual espgui::TextInterface
{
public:
std::string text() const override
{
return getBatteryCellTypeString();
}
};
template<BatteryCellType T>
class BatterySelectTypeAction : public virtual espgui::ActionInterface
@ -17,10 +48,9 @@ public:
};
} // namespace
using namespace espgui;
BatteryTypeMenu::BatteryTypeMenu()
{
using namespace espgui;
constructMenuItem<makeComponent<MenuItem, CurrentBatteryTypeText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_TYPE_22P>, BatterySelectTypeAction<BatteryCellType::_22P>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BATTERY_TYPE_HG2>, BatterySelectTypeAction<BatteryCellType::HG2>>>();
@ -30,6 +60,11 @@ BatteryTypeMenu::BatteryTypeMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string BatteryTypeMenu::text() const
{
return TEXT_SELECT_CELL_TYPE;
}
void BatteryTypeMenu::back()
{
espgui::switchScreen<BatteryMenu>();

15
main/displays/menus/selectbatterytypemenu.h
View File

@ -1,23 +1,14 @@
#pragma once
// 3rdparty lib includes
#include <menuitem.h>
#include <icons/back.h>
#include <actions/switchscreenaction.h>
#include <actioninterface.h>
// Local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#include "batterymenu.h"
#include "displays/menus/mainmenu.h"
class BatteryTypeMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_SELECT_CELL_TYPE>
class BatteryTypeMenu : public BobbyMenuDisplay
{
public:
BatteryTypeMenu();
std::string text() const override;
void back() override;
};

37
main/displays/menus/selectbuildserverbranch.cpp
View File

@ -15,15 +15,14 @@
#include "utils.h"
#include "newsettings.h"
#define ERR_MESSAGE(text) \
constructMenuItem<makeComponent<MenuItem, StaticText<text>, DefaultFont, StaticColor<TFT_RED>, DummyAction>>(); \
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>(); \
return;
using namespace espgui;
using namespace buildserver;
namespace {
constexpr char TEXT_OTA_NOBUILDSERVERAVAILABLE[] = "E:No server saved.";
constexpr char TEXT_OTA_NOBUILDSERVERSELECTED[] = "E:No server selected.";
constexpr char TEXT_OTA_NOCONNECTION[] = "E:No internet.";
constexpr char TEXT_SELECT_BRANCH[] = "Select Branch";
constexpr char TEXT_SELECT_BRANCH_CLEAR[] = "Clear Branch";
constexpr char TEXT_BACK[] = "Back";
class CurrentBranch : public virtual espgui::TextInterface
{
public:
@ -83,6 +82,14 @@ void ClearBranchAction::triggered()
SelectBuildserverBranchMenu::SelectBuildserverBranchMenu()
{
using namespace espgui;
using namespace buildserver;
#define ERR_MESSAGE(text) \
constructMenuItem<makeComponent<MenuItem, StaticText<text>, DefaultFont, StaticColor<TFT_RED>, DummyAction>>(); \
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>(); \
return;
if (count_available_buildserver() < 1)
{
ERR_MESSAGE(TEXT_OTA_NOBUILDSERVERAVAILABLE); // E:No server saved.
@ -97,14 +104,22 @@ SelectBuildserverBranchMenu::SelectBuildserverBranchMenu()
{
ERR_MESSAGE(TEXT_OTA_NOCONNECTION); // E:No internet.
}
#undef ERR_MESSAGE
SelectBranch::setup_request();
SelectBranch::start_descriptor_request(configs.otaServerUrl.value);
}
std::string SelectBuildserverBranchMenu::text() const
{
return TEXT_SELECT_BRANCH;
}
void SelectBuildserverBranchMenu::update()
{
using namespace SelectBranch;
using namespace espgui;
using namespace buildserver::SelectBranch;
if(get_request_running())
{
check_descriptor_request();
@ -138,11 +153,13 @@ void SelectBuildserverBranchMenu::update()
void SelectBuildserverBranchMenu::back()
{
switchScreen<OtaMenu>();
espgui::switchScreen<OtaMenu>();
}
void SelectBuildserverBranchMenu::buildMenuRequestError(std::string error)
{
using namespace espgui;
auto &item = constructMenuItem<makeComponent<MenuItem, ChangeableText, DefaultFont, StaticColor<TFT_RED>, DummyAction>>();
item.setTitle(error);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();

7
main/displays/menus/selectbuildserverbranch.h
View File

@ -2,18 +2,17 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#ifdef FEATURE_OTA
class SelectBuildserverBranchMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_SELECT_BRANCH>
class SelectBuildserverBranchMenu : public BobbyMenuDisplay
{
using Base = espgui::MenuDisplay;
public:
SelectBuildserverBranchMenu();
std::string text() const override;
void buildMenuRequestError(std::string error);
void update() override;
void back() override;

12
main/displays/menus/selectbuildservermenu.cpp
View File

@ -18,9 +18,12 @@
#ifdef FEATURE_OTA
using namespace buildserver::SelectBuild;
using namespace espgui;
namespace {
constexpr char TEXT_SELECTBUILDSERVERMENU[] = "Select Buildserver";
constexpr char TEXT_NOBUILDSERVERCONFIGURED[] = "Not configured";
constexpr char TEXT_BACK[] = "Back";
class BuildserverMenuItem : public espgui::MenuItem
{
public:
@ -49,6 +52,8 @@ private:
SelectBuildServerMenu::SelectBuildServerMenu()
{
using namespace espgui;
for (const auto &otaServer : configs.otaServers)
{
std::string url = otaServer.url.value;
@ -70,6 +75,11 @@ SelectBuildServerMenu::SelectBuildServerMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string SelectBuildServerMenu::text() const
{
return TEXT_SELECTBUILDSERVERMENU;
}
void SelectBuildServerMenu::back()
{
espgui::switchScreen<OtaMenu>();

7
main/displays/menus/selectbuildservermenu.h
View File

@ -4,17 +4,16 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#ifdef FEATURE_OTA
class SelectBuildServerMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_SELECTBUILDSERVERMENU>
class SelectBuildServerMenu : public BobbyMenuDisplay
{
public:
SelectBuildServerMenu();
std::string text() const override;
void back() override;
};
#endif

14
main/displays/menus/selectmodemenu.cpp
View File

@ -19,6 +19,15 @@
#include "displays/menus/mainmenu.h"
namespace {
constexpr char TEXT_SELECTMODE[] = "Select mode";
constexpr char TEXT_DEFAULT[] = "Default";
constexpr char TEXT_TEMPOMAT[] = "Tempomat";
constexpr char TEXT_LARSM[] = "Larsm";
constexpr char TEXT_REMOTECONTROL[] = "Remote control";
constexpr char TEXT_GAMETRAK[] = "Gametrak";
constexpr char TEXT_MOTORTEST[] = "Motortest";
constexpr char TEXT_BACK[] = "Back";
template<typename T1, T1 &target, typename T2, T2 value>
class SetterAction : public espgui::ActionInterface
{
@ -50,6 +59,11 @@ SelectModeMenu::SelectModeMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string SelectModeMenu::text() const
{
return TEXT_SELECTMODE;
}
void SelectModeMenu::start()
{
Base::start();

7
main/displays/menus/selectmodemenu.h
View File

@ -2,17 +2,16 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class SelectModeMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_SELECTMODE>
class SelectModeMenu : public BobbyMenuDisplay
{
using Base = BobbyMenuDisplay;
public:
SelectModeMenu();
std::string text() const override;
void start() override;
void back() override;
};

13
main/displays/menus/selectotabuildmenu.cpp
View File

@ -22,6 +22,14 @@ using namespace espgui;
using namespace buildserver::SelectBuild;
namespace {
constexpr char TEXT_UPDATENOW[] = "Update now";
constexpr char TEXT_SELECTBUILD[] = "Select build";
constexpr char TEXT_OTA_NOBUILDSERVERAVAILABLE[] = "E:No server saved.";
constexpr char TEXT_OTA_NOBUILDSERVERSELECTED[] = "E:No server selected.";
constexpr char TEXT_OTA_NOCONNECTION[] = "E:No internet.";
constexpr char TEXT_OTA_WAITFORRESPONSE[] = "Wait for response...";
constexpr char TEXT_BACK[] = "Back";
template<int item_color>
class VersionMenuItem : public MenuItem
{
@ -89,6 +97,11 @@ SelectBuildMenu::SelectBuildMenu()
}
}
std::string SelectBuildMenu::text() const
{
return TEXT_SELECTBUILD;
}
void SelectBuildMenu::update()
{
if(get_request_running())

8
main/displays/menus/selectotabuildmenu.h
View File

@ -2,18 +2,18 @@
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
#ifdef FEATURE_OTA
class SelectBuildMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_SELECTBUILD>
class SelectBuildMenu : public BobbyMenuDisplay
{
using Base = BobbyMenuDisplay;
public:
SelectBuildMenu();
std::string text() const override;
void update() override;
void back() override;

Some files were not shown because too many files have changed in this diff Show More