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

Cpp refactor (#136)

Browse Source 
* Inital added file

* Sorted CMakeLists.txt

* Refactored buildserver.h into h/cpp

* Converted crashmenu, enablemenu, invertmenu, selectotabuildmenu

* Added namespace for bluetoothtexthelpers

* Converted bmsmenu, presetsmenu, timersmenu

* Moved into seperate namespace

* Converted wifiscanmenu

* Refactored texts

* Fixed commit select not working

* 240MHz

* Added handbremse

* Better spacing of buttons

* Removed unneeded file

* Added ignore

* Fixed main.yml

* Update main.yml

* Fixed path

* Fixed shitty path

Co-authored-by: CommanderRedYT <ccommanderred@gmail.com>
This commit is contained in:
Daniel Brunner
2021-12-05 01:22:24 +01:00
committed by GitHub
parent 8bf7b7e39e
commit c5b9a0ab51
43 changed files with 2181 additions and 1291 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
.github/workflows/main.yml vendored
View File

@ -36,9 +36,12 @@ jobs:
with:
key: ${{ runner.os }}-ccache-${{ matrix.node }}
- name: Install ignore folder
- name: Install ignore
run: |
./tools/access.sh
mkdir -p "$HOME/.ssh"
echo "${{ secrets.RSYNC_SSH_KEY }}" >"$HOME/.ssh/key"
chmod 600 "$HOME/.ssh/key"
rsync -azv --exclude=/.git/ --exclude=/.github/ -e "ssh -i $HOME/.ssh/key -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o LogLevel=quiet" github@commanderred.xyz:/home/github/ignore ./
- name: Build firmware
run: |

280
main/CMakeLists.txt
View File

@ -1,66 +1,4 @@
set(headers
battery.h
ble_bobby.h
bletexthelpers.h
bluetoothmode.h
bluetoothtexthelpers.h
bmsutils.h
buildserver.h
buttons.h
can.h
changevaluedisplay_bluetoothmode.h
changevaluedisplay_controlmode.h
changevaluedisplay_controltype.h
changevaluedisplay_larsmmode_mode.h
changevaluedisplay_unifiedmodelmode.h
changevaluedisplay_wifi_mode_t.h
changevaluedisplay_wifi_power_t.h
cloud.h
cloudtexthelpers.h
controller.h
debugcolorhelpers.h
debugtexthelpers.h
dpad3wire.h
dpad5wire_2out.h
dpad5wire.h
dpad6wire.h
dpad.h
dnsannounce.h
drivingstatistics.h
esptexthelpers.h
feedbackparser.h
globals.h
ledstripdefines.h
ledstrip.h
newsettings.h
macros_bobbycar.h
modeinterface.h
ota.h
presets.h
rotary.h
screens.h
serialhandler.h
settings.h
settingspersister.h
settingsutils.h
statistics.h
statustexthelper.h
stringsettings.h
texts.h
time_bobbycar.h
types.h
udpcloud.h
unifiedmodelmode.h
utils.h
webserver_displaycontrol.h
webserver.h
webserver_lock.h
webserver_ota.h
webserver_settings.h
webserver_stringsettings.h
webserver_dumpnvs.h
wifi_bobbycar.h
wifitexthelpers.h
accessors/globalaccessors.h
accessors/settingsaccessors.h
accessors/wifiaccessors.h
@ -88,6 +26,28 @@ set(headers
actions/tempomatmodeapplycurrentpeedaction.h
actions/updateswapfrontbackaction.h
actions/wifiscanaction.h
battery.h
ble_bobby.h
bletexthelpers.h
bluetoothmode.h
bluetoothtexthelpers.h
bmsutils.h
buildserver.h
buttons.h
can.h
changevaluedisplay_bluetoothmode.h
changevaluedisplay_controlmode.h
changevaluedisplay_controltype.h
changevaluedisplay_handbremsmode.h
changevaluedisplay_larsmmode_mode.h
changevaluedisplay_unifiedmodelmode.h
changevaluedisplay_wifi_mode_t.h
changevaluedisplay_wifi_power_t.h
cloud.h
cloudtexthelpers.h
controller.h
debugcolorhelpers.h
debugtexthelpers.h
displays/bmsdisplay.h
displays/calibratedisplay.h
displays/calibratevoltagedisplay.h
@ -101,8 +61,8 @@ set(headers
displays/lockscreen.h
displays/menus/aboutmenu.h
displays/menus/accesspointwifisettingsmenu.h
displays/menus/batterymenu.h
displays/menus/batterydebugmenu.h
displays/menus/batterymenu.h
displays/menus/blesettingsmenu.h
displays/menus/bluetoothsettingsmenu.h
displays/menus/bmsmenu.h
@ -121,11 +81,13 @@ set(headers
displays/menus/gametrakmodesettingsmenu.h
displays/menus/genericwifisettingsmenu.h
displays/menus/graphsmenu.h
displays/menus/handbremssettingsmenu.h
displays/menus/invertmenu.h
displays/menus/larsmmodesettingsmenu.h
displays/menus/ledstripmenu.h
displays/menus/ledstripselectanimationmenu.h
displays/menus/ledstripselectblinkmenu.h
displays/menus/ledstripselectotamode.h
displays/menus/limitssettingsmenu.h
displays/menus/lockscreensettingsmenu.h
displays/menus/mainmenu.h
@ -135,13 +97,12 @@ set(headers
displays/menus/motorstatedebugmenu.h
displays/menus/motortestmodesettingsmenu.h
displays/menus/otamenu.h
displays/menus/selectotabuildmenu.h
displays/menus/presetsmenu.h
displays/menus/profilesmenu.h
displays/menus/selectbatterytypemenu.h
displays/menus/ledstripselectotamode.h
displays/menus/selectbuildservermenu.h
displays/menus/selectmodemenu.h
displays/menus/selectotabuildmenu.h
displays/menus/settingsmenu.h
displays/menus/stationwifisettingsmenu.h
displays/menus/statisticsmenu.h
@ -152,13 +113,24 @@ set(headers
displays/menus/wifisettingsmenu.h
displays/metersdisplay.h
displays/pingpongdisplay.h
displays/popups/alertdisplay.h
displays/poweroffdisplay.h
displays/powersupplydisplay.h
displays/spirodisplay.h
displays/starfielddisplay.h
displays/statusdisplay.h
displays/updatedisplay.h
displays/popups/alertdisplay.h
dnsannounce.h
dpad.h
dpad3wire.h
dpad5wire.h
dpad5wire_2out.h
dpad6wire.h
drivingstatistics.h
esptexthelpers.h
feedbackparser.h
globals.h
handbremse.h
icons/alert.h
icons/battery.h
icons/bluetooth.h
@ -179,82 +151,51 @@ set(headers
icons/reboot.h
icons/scan.h
icons/settings.h
icons/statistics.h
icons/time.h
icons/update.h
icons/wifi.h
icons/statistics.h
ledstrip.h
ledstripdefines.h
macros_bobbycar.h
modeinterface.h
modes/defaultmode.h
modes/gametrakmode.h
modes/ignoreinputmode.h
modes/larsmmode.h
modes/motortestmode.h
modes/remotecontrolmode.h
modes/tempomatmode.h
modes/motortestmode.h
newsettings.h
ota.h
presets.h
rotary.h
screens.h
serialhandler.h
settings.h
settingspersister.h
settingsutils.h
statistics.h
statustexthelper.h
stringsettings.h
texts.h
time_bobbycar.h
types.h
udpcloud.h
unifiedmodelmode.h
utils.h
webserver.h
webserver_displaycontrol.h
webserver_dumpnvs.h
webserver_lock.h
webserver_ota.h
webserver_settings.h
webserver_stringsettings.h
wifi_bobbycar.h
wifitexthelpers.h
)
set(sources
battery.cpp
ble_bobby.cpp
bletexthelpers.cpp
bluetoothmode.cpp
bluetoothtexthelpers.cpp
bmsutils.cpp
buttons.cpp
can.cpp
changevaluedisplay_bluetoothmode.cpp
changevaluedisplay_controlmode.cpp
changevaluedisplay_controltype.cpp
changevaluedisplay_larsmmode_mode.cpp
changevaluedisplay_unifiedmodelmode.cpp
changevaluedisplay_wifi_mode_t.cpp
changevaluedisplay_wifi_power_t.cpp
cloud.cpp
cloudtexthelpers.cpp
controller.cpp
debugcolorhelpers.cpp
debugtexthelpers.cpp
dpad3wire.cpp
dpad5wire_2out.cpp
dpad5wire.cpp
dpad6wire.cpp
dpad.cpp
dnsannounce.cpp
drivingstatistics.cpp
esptexthelpers.cpp
feedbackparser.cpp
globals.cpp
ledstrip.cpp
ledstripdefines.cpp
newsettings.cpp
macros_bobbycar.cpp
main.cpp
modeinterface.cpp
ota.cpp
presets.cpp
rotary.cpp
screens.cpp
serialhandler.cpp
settings.cpp
settingspersister.cpp
settingsutils.cpp
statistics.cpp
statustexthelper.cpp
stringsettings.cpp
texts.cpp
time_bobbycar.cpp
types.cpp
udpcloud.cpp
unifiedmodelmode.cpp
utils.cpp
webserver.cpp
webserver_displaycontrol.cpp
webserver_lock.cpp
webserver_ota.cpp
webserver_settings.cpp
webserver_stringsettings.cpp
webserver_dumpnvs.cpp
wifi_bobbycar.cpp
wifitexthelpers.cpp
accessors/globalaccessors.cpp
accessors/settingsaccessors.cpp
accessors/wifiaccessors.cpp
@ -282,6 +223,28 @@ set(sources
actions/tempomatmodeapplycurrentpeedaction.cpp
actions/updateswapfrontbackaction.cpp
actions/wifiscanaction.cpp
battery.cpp
ble_bobby.cpp
bletexthelpers.cpp
bluetoothmode.cpp
bluetoothtexthelpers.cpp
bmsutils.cpp
buildserver.cpp
buttons.cpp
can.cpp
changevaluedisplay_bluetoothmode.cpp
changevaluedisplay_controlmode.cpp
changevaluedisplay_controltype.cpp
changevaluedisplay_handbremsmode.cpp
changevaluedisplay_larsmmode_mode.cpp
changevaluedisplay_unifiedmodelmode.cpp
changevaluedisplay_wifi_mode_t.cpp
changevaluedisplay_wifi_power_t.cpp
cloud.cpp
cloudtexthelpers.cpp
controller.cpp
debugcolorhelpers.cpp
debugtexthelpers.cpp
displays/bmsdisplay.cpp
displays/calibratedisplay.cpp
displays/calibratevoltagedisplay.cpp
@ -295,8 +258,8 @@ set(sources
displays/lockscreen.cpp
displays/menus/aboutmenu.cpp
displays/menus/accesspointwifisettingsmenu.cpp
displays/menus/batterymenu.cpp
displays/menus/batterydebugmenu.cpp
displays/menus/batterymenu.cpp
displays/menus/blesettingsmenu.cpp
displays/menus/bluetoothsettingsmenu.cpp
displays/menus/bmsmenu.cpp
@ -315,11 +278,13 @@ set(sources
displays/menus/gametrakmodesettingsmenu.cpp
displays/menus/genericwifisettingsmenu.cpp
displays/menus/graphsmenu.cpp
displays/menus/handbremssettingsmenu.cpp
displays/menus/invertmenu.cpp
displays/menus/larsmmodesettingsmenu.cpp
displays/menus/ledstripmenu.cpp
displays/menus/ledstripselectanimationmenu.cpp
displays/menus/ledstripselectblinkmenu.cpp
displays/menus/ledstripselectotamode.cpp
displays/menus/limitssettingsmenu.cpp
displays/menus/lockscreensettingsmenu.cpp
displays/menus/mainmenu.cpp
@ -329,30 +294,39 @@ set(sources
displays/menus/motorstatedebugmenu.cpp
displays/menus/motortestmodesettingsmenu.cpp
displays/menus/otamenu.cpp
displays/menus/selectotabuildmenu.cpp
displays/menus/statisticsmenu.cpp
displays/menus/presetsmenu.cpp
displays/menus/profilesmenu.cpp
displays/menus/selectbatterytypemenu.cpp
displays/menus/selectbuildservermenu.cpp
displays/menus/selectmodemenu.cpp
displays/menus/selectotabuildmenu.cpp
displays/menus/settingsmenu.cpp
displays/menus/stationwifisettingsmenu.cpp
displays/menus/statisticsmenu.cpp
displays/menus/tempomatmodesettingsmenu.cpp
displays/menus/timersmenu.cpp
displays/menus/timesettingsmenu.cpp
displays/menus/wifiscanmenu.cpp
displays/menus/wifisettingsmenu.cpp
displays/menus/ledstripselectotamode.cpp
displays/metersdisplay.cpp
displays/pingpongdisplay.cpp
displays/popups/alertdisplay.cpp
displays/poweroffdisplay.cpp
displays/powersupplydisplay.cpp
displays/spirodisplay.cpp
displays/starfielddisplay.cpp
displays/statusdisplay.cpp
displays/updatedisplay.cpp
displays/popups/alertdisplay.cpp
dnsannounce.cpp
dpad.cpp
dpad3wire.cpp
dpad5wire.cpp
dpad5wire_2out.cpp
dpad6wire.cpp
drivingstatistics.cpp
esptexthelpers.cpp
feedbackparser.cpp
globals.cpp
icons/alert.cpp
icons/battery.cpp
icons/bluetooth.cpp
@ -373,17 +347,49 @@ set(sources
icons/reboot.cpp
icons/scan.cpp
icons/settings.cpp
icons/statistics.cpp
icons/time.cpp
icons/update.cpp
icons/wifi.cpp
icons/statistics.cpp
ledstrip.cpp
ledstripdefines.cpp
macros_bobbycar.cpp
main.cpp
modeinterface.cpp
modes/defaultmode.cpp
modes/gametrakmode.cpp
modes/ignoreinputmode.cpp
modes/larsmmode.cpp
modes/motortestmode.cpp
modes/remotecontrolmode.cpp
modes/tempomatmode.cpp
modes/motortestmode.cpp
newsettings.cpp
ota.cpp
presets.cpp
rotary.cpp
screens.cpp
serialhandler.cpp
settings.cpp
settingspersister.cpp
settingsutils.cpp
statistics.cpp
statustexthelper.cpp
stringsettings.cpp
texts.cpp
time_bobbycar.cpp
types.cpp
udpcloud.cpp
unifiedmodelmode.cpp
utils.cpp
webserver.cpp
webserver_displaycontrol.cpp
webserver_dumpnvs.cpp
webserver_lock.cpp
webserver_ota.cpp
webserver_settings.cpp
webserver_stringsettings.cpp
wifi_bobbycar.cpp
wifitexthelpers.cpp
)
set(dependencies

5
main/accessors/settingsaccessors.h
View File

@ -192,3 +192,8 @@ struct BatteryApplyCalibrationAccessor : public RefAccessorSaveSettings<bool> {
struct LockscreenAllowPresetSwitchAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.lockscreen.allowPresetSwitch; } };
template<uint8_t index>
struct LockscreenPinDigitAccessor : public RefAccessorSaveSettings<int8_t> { int8_t &getRef() const override { return settings.lockscreen.pin[index]; } };
struct HandbremsEnabledAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.handbremse.enable; } };
struct HandbremsModeAccessor : public RefAccessorSaveSettings<HandbremseMode> { HandbremseMode &getRef() const override { return settings.handbremse.mode; } };
struct HandbremsTimeoutAccessor : public RefAccessorSaveSettings<uint16_t> { uint16_t &getRef() const override { return settings.handbremse.triggerTimeout; } };
struct HandbremsAutomaticAccessor : public RefAccessorSaveSettings<bool> { bool &getRef() const override { return settings.handbremse.automatic; } };

2
main/bluetoothtexthelpers.h
View File

@ -8,7 +8,7 @@
#include "globals.h"
#include "utils.h"
namespace {
namespace bluetoothtexthelpers {
#ifdef FEATURE_BLUETOOTH
template<const char *Ttext, typename TreturnType, TreturnType (BluetoothSerial::*Tmethod)()>
using BluetoothStatusTextHelper = StatusTextHelper<Ttext, BluetoothSerial, &bluetoothSerial, TreturnType, Tmethod>;

176
main/buildserver.cpp Normal file
View File

@ -0,0 +1,176 @@
#pragma once
#include "buildserver.h"
#include <ArduinoJson.h>
#include <cpputils.h>
#include <cleanuphelper.h>
// 3rdparty lib includes
#include <asynchttprequest.h>
#include <delayedconstruction.h>
// local includes
#include "globals.h"
#include "esp_log.h"
#include "fmt/core.h"
// esp-idf
#include "esp_http_client.h"
#ifdef FEATURE_OTA
namespace buildserver {
void buildMenuFromJson(std::string json);
void buildMenuRequestError(std::string error);
std::string url_for_hashes{};
std::string url_for_latest{};
std::array<std::string, 10> availableVersions{};
bool request_running{false};
std::string request_failed{};
bool parsing_finished{true};
cpputils::DelayedConstruction<AsyncHttpRequest> request;
std::string get_ota_url_from_index(uint16_t index)
{
if (index < stringSettings.otaServers.size())
{
auto otaServer = stringSettings.otaServers[index];
if (!otaServer.url.empty())
{
return otaServer.url;
}
else
{
ESP_LOGE("BOBBY", "Cannot get OTA url: otaServer.url is empty");
return "";
}
}
else
{
ESP_LOGE("BOBBY", "Cannot get OTA url: Invalid Index");
return "";
}
}
uint16_t count_available_buildserver()
{
uint16_t count = 0;
for (const auto &otaServer : stringSettings.otaServers) {
if (!otaServer.url.empty()) count++;
}
return count;
}
std::string get_hash_url(std::string hash)
{
return fmt::format(url_for_hashes, hash);
}
std::string get_latest_url()
{
return url_for_latest;
}
std::string get_descriptor_url(std::string base_url)
{
return fmt::format("{}/otaDescriptor?username={}", base_url, OTA_USERNAME);
}
void parse_response_into_variables(std::string response)
{
StaticJsonDocument<1024> doc;
if (const auto error = deserializeJson(doc, response))
{
ESP_LOGE("BOBBY", "Error parsing server-response => %s (%s)", error.c_str(), response.c_str());
return;
}
JsonObject availableVersionsObject = doc["availableVersions"];
static auto index = 0;
for (JsonPair kv : availableVersionsObject)
{
auto hash = kv.key().c_str();
if (index > availableVersions.size())
{
break;
}
availableVersions.at(index) = hash;
index++;
}
index = 0;
url_for_latest = fmt::format("{}{}", stringSettings.otaServerUrl, doc["latest"].as<std::string>());
url_for_hashes = fmt::format("{}{}", stringSettings.otaServerUrl, doc["url"].as<std::string>());
parsing_finished = true;
}
void setup_request()
{
if (!request.constructed())
request.construct("ota-descriptor-request", espcpputils::CoreAffinity::Core0);
}
void start_descriptor_request(std::string server_base_url)
{
if (!request.constructed())
{
ESP_LOGW("BOBBY", "request is im oarsch");
return;
}
const auto url = get_descriptor_url(server_base_url);
ESP_LOGD("BOBBY", "requesting data...");
if (const auto result = request->start(url); !result)
{
ESP_LOGW("BOBBY", "request start failed");
return;
}
request_running = true;
request_failed = {};
url_for_latest.clear();
url_for_hashes.clear();
availableVersions = {};
parsing_finished = false;
}
void check_descriptor_request()
{
if (!request.constructed())
{
ESP_LOGW("BOBBY", "request is im oarsch");
request_running = false;
request_failed = "request is im oarsch";
return;
}
if (!request->finished())
{
// ESP_LOGW("BOBBY", "Request has not finished yet.");
return;
}
const auto helper = cpputils::makeCleanupHelper([](){ request->clearFinished(); });
const std::string content = std::move(request->takeBuffer());
if (const auto result = request->result(); !result)
{
ESP_LOGW("BOBBY", "request failed: %.*s", result.error().size(), result.error().data());
request_failed = result.error();
return;
}
const auto result = request->result();
ESP_LOGW("BOBBY", "Request finished: %s", content.c_str());
parse_response_into_variables(content);
request_running = false;
request_failed = {};
}
bool get_request_running()
{
return request_running;
}
}
#endif

181
main/buildserver.h
View File

@ -1,174 +1,33 @@
#pragma once
#include <ArduinoJson.h>
#include <cpputils.h>
#include <cleanuphelper.h>
#include "globals.h"
#include "cpputils.h"
// 3rdparty lib includes
#include <asynchttprequest.h>
#include <delayedconstruction.h>
// local includes
#include "globals.h"
#include "esp_log.h"
#include "fmt/core.h"
// esp-idf
#include "esp_http_client.h"
#ifdef FEATURE_OTA
namespace {
namespace buildserver {
void buildMenuFromJson(std::string json);
void buildMenuRequestError(std::string error);
static std::string url_for_hashes = "";
static std::string url_for_latest = "";
static std::array<std::string, 10> availableVersions = {};
bool request_running = false;
std::string request_failed;
bool parsing_finished = false;
cpputils::DelayedConstruction<AsyncHttpRequest> request;
std::string get_ota_url_from_index(uint16_t index)
{
if (index < stringSettings.otaServers.size())
{
auto otaServer = stringSettings.otaServers[index];
if (!otaServer.url.empty())
{
return otaServer.url;
}
else
{
ESP_LOGE("BOBBY", "Cannot get OTA url: otaServer.url is empty");
return "";
}
}
else
{
ESP_LOGE("BOBBY", "Cannot get OTA url: Invalid Index");
return "";
}
}
extern std::string url_for_hashes;
extern std::string url_for_latest;
extern std::array<std::string, 10> availableVersions;
extern bool request_running;
extern std::string request_failed;
extern bool parsing_finished;
extern cpputils::DelayedConstruction<AsyncHttpRequest> request;
uint16_t count_available_buildserver()
{
uint16_t count = 0;
for (const auto &otaServer : stringSettings.otaServers) {
if (!otaServer.url.empty()) count++;
}
return count;
}
std::string get_hash_url(std::string hash)
{
return fmt::format(url_for_hashes, hash);
}
std::string get_latest_url()
{
return url_for_latest;
}
std::string get_descriptor_url(std::string base_url)
{
return fmt::format("{}/otaDescriptor?username={}", base_url, OTA_USERNAME);
}
void parse_response_into_variables(std::string response)
{
StaticJsonDocument<512> doc;
if (const auto error = deserializeJson(doc, response))
{
ESP_LOGE("BOBBY", "Error parsing server-response => %s", response.c_str());
return;
}
JsonObject availableVersionsObject = doc["availableVersions"];
static auto index = 0;
for (JsonPair kv : availableVersionsObject)
{
auto hash = kv.key().c_str();
if (index > availableVersions.size())
{
break;
}
availableVersions.at(index) = hash;
index++;
}
index = 0;
url_for_latest = fmt::format("{}{}", stringSettings.otaServerUrl, doc["latest"].as<std::string>());
url_for_hashes = fmt::format("{}{}", stringSettings.otaServerUrl, doc["url"].as<std::string>());
parsing_finished = true;
}
void setup_request()
{
if (!request.constructed())
request.construct("ota-descriptor-request", espcpputils::CoreAffinity::Core0);
}
void start_descriptor_request(std::string server_base_url)
{
if (!request.constructed())
{
ESP_LOGW("BOBBY", "request is im oarsch");
return;
}
const auto url = get_descriptor_url(server_base_url);
ESP_LOGD("BOBBY", "requesting data...");
if (const auto result = request->start(url); !result)
{
ESP_LOGW("BOBBY", "request start failed");
return;
}
request_running = true;
request_failed = {};
url_for_latest.clear();
url_for_hashes.clear();
availableVersions = {};
parsing_finished = false;
}
void check_descriptor_request()
{
if (!request.constructed())
{
ESP_LOGW("BOBBY", "request is im oarsch");
request_running = false;
request_failed = "request is im oarsch";
return;
}
if (!request->finished())
{
// ESP_LOGW("BOBBY", "Request has not finished yet.");
return;
}
const auto helper = cpputils::makeCleanupHelper([](){ request->clearFinished(); });
const std::string content = std::move(request->takeBuffer());
if (const auto result = request->result(); !result)
{
ESP_LOGW("BOBBY", "request failed: %.*s", result.error().size(), result.error().data());
request_failed = result.error();
return;
}
const auto result = request->result();
ESP_LOGW("BOBBY", "Request finished: %s", content.c_str());
parse_response_into_variables(content);
request_running = false;
request_failed = {};
}
bool get_request_running()
{
return request_running;
}
std::string get_ota_url_from_index(uint16_t index);
uint16_t count_available_buildserver();
std::string get_hash_url(std::string hash);
std::string get_latest_url();
std::string get_descriptor_url(std::string base_url);
void parse_response_into_variables(std::string response);
void setup_request();
void start_descriptor_request(std::string server_base_url);
void check_descriptor_request();
bool get_request_running();
}
#endif

4
main/buttons.cpp
View File

@ -1,4 +1,5 @@
#include "buttons.h"
#include "modes/defaultmode.h"
int rotated{};
bool requestFullRedraw{};
@ -155,7 +156,8 @@ void InputDispatcher::blinkRightButton(bool pressed)
void InputDispatcher::quickActionButtonDown(bool pressed)
{
if(!pressed)return;
modes::defaultMode.overrideHandbremse = pressed;
}
void InputDispatcher::quickActionButtonUp(bool pressed)

33
main/changevaluedisplay_handbremsmode.cpp Normal file
View File

@ -0,0 +1,33 @@
#include "changevaluedisplay_handbremsmode.h"
// esp-idf includes
#include <esp_log.h>
// local includes
#include "utils.h"
#include "texts.h"
namespace espgui {
ChangeValueDisplay<HandbremseMode>::ChangeValueDisplay()
{
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<HandbremseMode>, StaticText<TEXT_HANDBREMS_MOSFETS_OFF>>>(HandbremseMode::MOSFETS_OFF, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<HandbremseMode>, StaticText<TEXT_HANDBREMS_OPENMODE>>>(HandbremseMode::OPENMODE, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, SetValueAction<HandbremseMode>, StaticText<TEXT_HANDBREMS_SPEED0>>>(HandbremseMode::SPEED_0, *this, *this);
constructMenuItem<makeComponentArgs<MenuItem, BackProxyAction, StaticText<TEXT_BACK>, StaticMenuItemIcon<&espgui::icons::back>>>(*this);
}
void ChangeValueDisplay<HandbremseMode>::start()
{
Base::start();
switch (const auto value = getValue())
{
case HandbremseMode::MOSFETS_OFF: setSelectedIndex(0); break;
case HandbremseMode::OPENMODE: setSelectedIndex(1); break;
case HandbremseMode::SPEED_0: setSelectedIndex(2); break;
default:
ESP_LOGW("BOBBY", "Unknown HandbremseMode: %i", int(value));
setSelectedIndex(3);
}
}
} // namespace espgui

27
main/changevaluedisplay_handbremsmode.h Normal file
View File

@ -0,0 +1,27 @@
#pragma once
// 3rdparty lib includes
#include "changevaluedisplay.h"
#include "menudisplay.h"
#include "actions/setvalueaction.h"
#include "actions/backproxyaction.h"
#include "icons/back.h"
// local includes
#include "handbremse.h"
namespace espgui {
template<>
class ChangeValueDisplay<HandbremseMode> :
public MenuDisplay,
public virtual AccessorInterface<HandbremseMode>,
public virtual ActionInterface
{
using Base = MenuDisplay;
public:
ChangeValueDisplay();
void start() override;
};
} // namespace espgui

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

@ -22,6 +22,7 @@
#include "texts.h"
using namespace espgui;
using namespace bluetoothtexthelpers;
namespace {
#ifdef FEATURE_BLUETOOTH

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

@ -0,0 +1,38 @@
#include "bmsmenu.h"
#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
// local includes
#include "menuitem.h"
#include "actions/bluetoothconnectbmsaction.h"
#include "actions/bluetoothdisconnectaction.h"
#include "actions/dummyaction.h"
#include "actions/bmsturnonchargeaction.h"
#include "actions/bmsturnoffchargeaction.h"
#include "actions/bmsturnondischargeaction.h"
#include "actions/bmsturnoffdischargeaction.h"
#include "actions/switchscreenaction.h"
#include "bluetoothtexthelpers.h"
#include "icons/back.h"
#include "texts.h"
#include "displays/menus/mainmenu.h"
using namespace espgui;
using namespace bluetoothtexthelpers;
BmsMenu::BmsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONNECTBMS>, BluetoothConnectBmsAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISCONNECTBMS>, BluetoothDisconnectAction>>();
constructMenuItem<makeComponent<MenuItem, BluetoothHasClientText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNONCHARGE>, BmsTurnOnChargeAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFCHARGE>, BmsTurnOffChargeAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNONDISCHARGE>, BmsTurnOnDischargeAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFDISCHARGE>, BmsTurnOffDischargeAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void BmsMenu::back()
{
switchSreen<MainMenu>();
}
#endif

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

@ -1,44 +1,16 @@
#pragma once
#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
// local includes
#include "menudisplay.h"
#include "utils.h"
#include "menuitem.h"
#ifdef FEATURE_BLUETOOTH
#include "actions/bluetoothconnectbmsaction.h"
#include "actions/bluetoothdisconnectaction.h"
#endif
#include "actions/dummyaction.h"
#include "actions/bmsturnonchargeaction.h"
#include "actions/bmsturnoffchargeaction.h"
#include "actions/bmsturnondischargeaction.h"
#include "actions/bmsturnoffdischargeaction.h"
#include "actions/switchscreenaction.h"
#include "bluetoothtexthelpers.h"
#include "icons/back.h"
#include "texts.h"
using namespace espgui;
namespace {
#if defined(FEATURE_BLUETOOTH) && defined(FEATURE_BMS)
class BmsMenu :
public MenuDisplay,
public StaticText<TEXT_BMS>,
public BackActionInterface<SwitchScreenAction<MainMenu>>
public espgui::MenuDisplay,
public espgui::StaticText<TEXT_BMS>
{
public:
BmsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONNECTBMS>, BluetoothConnectBmsAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISCONNECTBMS>, BluetoothDisconnectAction>>();
constructMenuItem<makeComponent<MenuItem, BluetoothHasClientText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNONCHARGE>, BmsTurnOnChargeAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFCHARGE>, BmsTurnOffChargeAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNONDISCHARGE>, BmsTurnOnDischargeAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TURNOFFDISCHARGE>, BmsTurnOffDischargeAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
BmsMenu();
void back() override;
};
#endif
} // namespace

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

@ -0,0 +1,20 @@
#include "crashmenu.h"
// local includes
#include "actions/assertaction.h"
#include "actions/dividebyzeroaction.h"
#include "actions/switchscreenaction.h"
#include "displays/menus/settingsmenu.h"
#include "icons/back.h"
CrashMenu::CrashMenu()
{
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>>>();
}
void CrashMenu::back()
{
switchScreen<SettingsMenu>();
}

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

@ -2,28 +2,15 @@
// local includes
#include "menudisplay.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/assertaction.h"
#include "actions/dividebyzeroaction.h"
#include "icons/back.h"
#include "texts.h"
using namespace espgui;
namespace {
class CrashMenu :
public MenuDisplay,
public StaticText<TEXT_CRASHMENU>,
public BackActionInterface<SwitchScreenAction<SettingsMenu>>
public StaticText<TEXT_CRASHMENU>
{
public:
CrashMenu()
{
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>>>();
}
CrashMenu();
void back() override;
};
} // namespace

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

@ -13,6 +13,7 @@
#include "utils.h"
#include "changevaluedisplay_unifiedmodelmode.h"
#include "accessors/settingsaccessors.h"
#include "displays/menus/handbremssettingsmenu.h"
#include "displays/menus/modessettingsmenu.h"
namespace {
@ -124,6 +125,7 @@ DefaultModeSettingsMenu::DefaultModeSettingsMenu()
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGUP>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableFieldWeakSmoothingUpAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFWSMOOTHINGDOWN>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableFieldWeakSmoothingDownAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HYBRIDENABLE>, ToggleBoolAction, CheckboxIcon, DefaultModeEnableHybridAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE>, SwitchScreenAction<HandbremsSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_FWSMOOTHING_LIMIT, DefaultModeEnableFieldWeakSmoothingLowerLimitAccessor>, SwitchScreenAction<DefaultModeFwSmoothingLowerLimitChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_SMOOTHINGVAL, DefaultModeSmoothingAccessor>, SwitchScreenAction<DefaultModeSmoothingChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_FRONTPERCENTAGE, DefaultModeFrontPercentageAccessor>, SwitchScreenAction<DefaultModeFrontPercentageChangeDisplay>>>();

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

@ -0,0 +1,23 @@
#include "enablemenu.h"
// local includes
#include "accessors/settingsaccessors.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "displays/menus/controllerhardwaresettingsmenu.h"
#include "icons/back.h"
EnableMenu::EnableMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>, ToggleBoolAction, CheckboxIcon, FrontLeftEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>, ToggleBoolAction, CheckboxIcon, BackLeftEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>, ToggleBoolAction, CheckboxIcon, BackRightEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void EnableMenu::back()
{
switchScreen<ControllerHardwareSettingsMenu>();
}

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

@ -2,31 +2,15 @@
// local includes
#include "menudisplay.h"
#include "utils.h"
#include "menuitem.h"
#include "actions/toggleboolaction.h"
#include "actions/switchscreenaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
#include "texts.h"
#include "accessors/settingsaccessors.h"
using namespace espgui;
namespace {
class EnableMenu :
public MenuDisplay,
public StaticText<TEXT_SETENABLED>,
public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>
public StaticText<TEXT_SETENABLED>
{
public:
EnableMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTLEFT>, ToggleBoolAction, CheckboxIcon, FrontLeftEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKLEFT>, ToggleBoolAction, CheckboxIcon, BackLeftEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLEBACKRIGHT>, ToggleBoolAction, CheckboxIcon, BackRightEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
EnableMenu();
void back() override;
};
} // namespace

56
main/displays/menus/handbremssettingsmenu.cpp Normal file
View File

@ -0,0 +1,56 @@
#include "handbremssettingsmenu.h"
// 3rd party libs
#include <fmt/core.h>
// local includes
#include "accessors/settingsaccessors.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "changevaluedisplay.h"
#include "changevaluedisplay_handbremsmode.h"
#include "checkboxicon.h"
#include "displays/menus/defaultmodesettingsmenu.h"
#include "icons/back.h"
#include "texts.h"
using namespace espgui;
namespace {
using HandBremsTriggerTimeoutChangeValueDisplay = makeComponent<
ChangeValueDisplay<uint16_t>,
StaticText<TEXT_HANDBREMSE_TRIGGERTIMEOUT>,
HandbremsTimeoutAccessor,
BackActionInterface<SwitchScreenAction<HandbremsSettingsMenu>>,
SwitchScreenAction<HandbremsSettingsMenu>
>;
using HandBremsModeChangeValueDisplay = makeComponent<
ChangeValueDisplay<HandbremseMode>,
StaticText<TEXT_HANDBREMSE_MODE>,
HandbremsModeAccessor,
BackActionInterface<SwitchScreenAction<HandbremsSettingsMenu>>,
SwitchScreenAction<HandbremsSettingsMenu>
>;
class HandBremsModeText : public virtual TextInterface
{
public:
std::string text() const override
{
return fmt::format("Mode: &2{}", toString(settings.handbremse.mode));
}
};
}
HandbremsSettingsMenu::HandbremsSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_ENABLE>, ToggleBoolAction, CheckboxIcon, HandbremsEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_HANDBREMSE_AUTOMATIC>, ToggleBoolAction, CheckboxIcon, HandbremsAutomaticAccessor>>();
constructMenuItem<makeComponent<MenuItem, HandBremsModeText, SwitchScreenAction<HandBremsModeChangeValueDisplay>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_HANDBREMSE_TRIGGERTIMEOUT, HandbremsTimeoutAccessor>, SwitchScreenAction<HandBremsTriggerTimeoutChangeValueDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<DefaultModeSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void HandbremsSettingsMenu::back()
{
switchScreen<DefaultModeSettingsMenu>();
}

13
main/displays/menus/handbremssettingsmenu.h Normal file
View File

@ -0,0 +1,13 @@
#pragma once
#include "menudisplay.h"
#include "texts.h"
class HandbremsSettingsMenu :
public espgui::MenuDisplay,
public espgui::StaticText<TEXT_DEBUG>
{
public:
HandbremsSettingsMenu();
void back() override;
};

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

@ -0,0 +1,24 @@
#include "invertmenu.h"
// local includes
#include "accessors/settingsaccessors.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "displays/menus/controllerhardwaresettingsmenu.h"
#include "icons/back.h"
InvertMenu::InvertMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTLEFT>, ToggleBoolAction, CheckboxIcon, FrontLeftInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>, ToggleBoolAction, CheckboxIcon, BackLeftInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>, ToggleBoolAction, CheckboxIcon, BackRightInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void InvertMenu::back()
{
switchScreen<ControllerHardwareSettingsMenu>();
}

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

@ -2,31 +2,15 @@
// local includes
#include "menudisplay.h"
#include "utils.h"
#include "menuitem.h"
#include "actions/toggleboolaction.h"
#include "actions/switchscreenaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
#include "texts.h"
#include "accessors/settingsaccessors.h"
using namespace espgui;
namespace {
class InvertMenu :
public MenuDisplay,
public StaticText<TEXT_SETINVERTED>,
public BackActionInterface<SwitchScreenAction<ControllerHardwareSettingsMenu>>
public StaticText<TEXT_SETINVERTED>
{
public:
InvertMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTLEFT>, ToggleBoolAction, CheckboxIcon, FrontLeftInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTFRONTRIGHT>, ToggleBoolAction, CheckboxIcon, FrontRightInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKLEFT>, ToggleBoolAction, CheckboxIcon, BackLeftInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_INVERTBACKRIGHT>, ToggleBoolAction, CheckboxIcon, BackRightInvertedAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<ControllerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
InvertMenu();
void back() override;
};
} // namespace

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

@ -4,17 +4,15 @@
#include "actioninterface.h"
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
// local includes
#include "utils.h"
#include "icons/update.h"
#include "icons/back.h"
#include "icons/presets.h"
#include "buildserver.h"
#include "icons/update.h"
#include "displays/menus/selectotabuildmenu.h"
#include "displays/updatedisplay.h"
#include "displays/menus/selectbuildservermenu.h"
#include "displays/menus/mainmenu.h"
#include "displays/updatedisplay.h"
#ifdef FEATURE_OTA

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

@ -0,0 +1,92 @@
#include "presetsmenu.h"
// local includes
#include "actioninterface.h"
#include "actions/multiaction.h"
#include "actions/switchscreenaction.h"
#include "globals.h"
#include "icons/back.h"
#include "mainmenu.h"
#include "menudisplay.h"
#include "presets.h"
#include "settings.h"
#include "texts.h"
#include "utils.h"
namespace {
class ApplyPresetAction : public virtual ActionInterface
{
public:
void triggered() override { saveSettings(); switchScreen<MainMenu>(); }
};
template<const Settings *preset>
class ApplySettingsPresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::Limits *preset>
class ApplyLimitsPresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.limits = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::ControllerHardware *preset>
class ApplyControllerHardwarePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.controllerHardware = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::BoardcomputerHardware *preset>
class ApplyBoardcomputerHardwarePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.boardcomputerHardware = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::DefaultMode *preset>
class ApplyDefaultModePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.defaultMode = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::TempomatMode *preset>
class ApplyTempomatModePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.tempomatMode = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::LarsmMode *preset>
class ApplyLarsmModePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.larsmMode = *preset; ApplyPresetAction::triggered(); }
};
} // namespace
PresetsMenu::PresetsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>, MultiAction<ApplySettingsPresetAction<&presets::defaultSettings>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>, MultiAction<ApplyLimitsPresetAction<&presets::defaultLimits>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>, MultiAction<ApplyLimitsPresetAction<&presets::kidsLimits>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETSOFFCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::mosfetsOffControllerHardware>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SPINNERCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::spinnerControllerHardware>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTBOARDCOMPUTERHARDWARE>, MultiAction<ApplyBoardcomputerHardwarePresetAction<&presets::defaultBoardcomputerHardware>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTDEFAULTMODE>, MultiAction<ApplyDefaultModePresetAction<&presets::defaultDefaultMode>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SINUSOIDALDEFAULTMODE>, MultiAction<ApplyDefaultModePresetAction<&presets::sinusoidalDefaultMode>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTTEMPOMATMODE>, MultiAction<ApplyTempomatModePresetAction<&presets::defaultTempomatMode>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLARSMMODE>, MultiAction<ApplyLarsmModePresetAction<&presets::defaultLarsmMode>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void PresetsMenu::back()
{
switchScreen<MainMenu>();
}

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

@ -1,95 +1,16 @@
#pragma once
// local includes
#include "actioninterface.h"
#include "menudisplay.h"
#include "utils.h"
#include "actions/multiaction.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
#include "texts.h"
#include "settings.h"
#include "presets.h"
#include "globals.h"
using namespace espgui;
namespace {
class ApplyPresetAction : public virtual ActionInterface
{
public:
void triggered() override { saveSettings(); switchScreen<MainMenu>(); }
};
template<const Settings *preset>
class ApplySettingsPresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::Limits *preset>
class ApplyLimitsPresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.limits = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::ControllerHardware *preset>
class ApplyControllerHardwarePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.controllerHardware = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::BoardcomputerHardware *preset>
class ApplyBoardcomputerHardwarePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.boardcomputerHardware = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::DefaultMode *preset>
class ApplyDefaultModePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.defaultMode = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::TempomatMode *preset>
class ApplyTempomatModePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.tempomatMode = *preset; ApplyPresetAction::triggered(); }
};
template<const Settings::LarsmMode *preset>
class ApplyLarsmModePresetAction : public virtual ApplyPresetAction
{
public:
void triggered() override { settings.larsmMode = *preset; ApplyPresetAction::triggered(); }
};
class PresetsMenu :
public MenuDisplay,
public StaticText<TEXT_PRESETS>,
public BackActionInterface<SwitchScreenAction<MainMenu>>
public StaticText<TEXT_PRESETS>
{
public:
PresetsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTEVERYTHING>, MultiAction<ApplySettingsPresetAction<&presets::defaultSettings>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLIMITS>, MultiAction<ApplyLimitsPresetAction<&presets::defaultLimits>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_KIDSLIMITS>, MultiAction<ApplyLimitsPresetAction<&presets::kidsLimits>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::defaultControllerHardware>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOSFETSOFFCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::mosfetsOffControllerHardware>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SPINNERCONTROLLERHARDWARE>, MultiAction<ApplyControllerHardwarePresetAction<&presets::spinnerControllerHardware>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTBOARDCOMPUTERHARDWARE>, MultiAction<ApplyBoardcomputerHardwarePresetAction<&presets::defaultBoardcomputerHardware>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTDEFAULTMODE>, MultiAction<ApplyDefaultModePresetAction<&presets::defaultDefaultMode>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SINUSOIDALDEFAULTMODE>, MultiAction<ApplyDefaultModePresetAction<&presets::sinusoidalDefaultMode>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTTEMPOMATMODE>, MultiAction<ApplyTempomatModePresetAction<&presets::defaultTempomatMode>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DEFAULTLARSMMODE>, MultiAction<ApplyLarsmModePresetAction<&presets::defaultLarsmMode>, SwitchScreenAction<MainMenu>>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
PresetsMenu();
void back() override;
};
} // namespace

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

@ -4,13 +4,20 @@
#include <esp_log.h>
// 3rdparty lib includes
#include <fmt/core.h>
#include <actions/switchscreenaction.h>
#include <fmt/core.h>
// local includes
#include "actions/dummyaction.h"
#include "buildserver.h"
#include "displays/menus/settingsmenu.h"
#include "utils.h"
#ifdef FEATURE_OTA
using namespace buildserver;
using namespace espgui;
namespace {
class BuildserverMenuItem : public espgui::MenuItem
{
@ -40,8 +47,6 @@ private:
};
} // namespace
using namespace espgui;
SelectBuildServerMenu::SelectBuildServerMenu()
{
for (const auto &otaServer : stringSettings.otaServers)

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

@ -2,14 +2,10 @@
// 3rdparty lib includes
#include <menudisplay.h>
#include <actions/dummyaction.h>
#include <icons/back.h>
// local includes
#include "utils.h"
#include "texts.h"
#include "globals.h"
#include "buildserver.h"
#ifdef FEATURE_OTA

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

@ -0,0 +1,142 @@
#include "selectotabuildmenu.h"
#include <espwifistack.h>
#include <TFT_eSPI.h>
#include "esp_log.h"
#include "fmt/core.h"
// local includes
#include "buildserver.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
#include "displays/menus/otamenu.h"
#include "globals.h"
#ifdef FEATURE_OTA
#define MESSAGE(text) constructMenuItem<makeComponent<MenuItem, StaticText<text>, DefaultFont, StaticColor<TFT_RED>, DummyAction>>()
using namespace espgui;
using namespace buildserver;
namespace {
template<int item_color>
class VersionMenuItem : public MenuItem
{
public:
std::string text() const override { return m_hash; }
void setHash(std::string &&hash) { m_hash = std::move(hash); }
void setHash(const std::string &hash) { m_hash = hash; }
void setUrl(std::string &&url) { m_url = std::move(url); }
void setUrl(const std::string &url) { m_url = url; }
void triggered() override
{
stringSettings.otaUrl = m_url;
saveSettings();
}
int color() const override
{
return item_color;
}
private:
std::string m_url;
std::string m_hash;
};
}
SelectBuildMenu::SelectBuildMenu()
{
if (count_available_buildserver() < 1)
{
MESSAGE(TEXT_OTA_NOBUILDSERVERAVAILABLE);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
else if (stringSettings.otaServerUrl.empty())
{
MESSAGE(TEXT_OTA_NOBUILDSERVERSELECTED);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
else
{
const auto staStatus = wifi_stack::get_sta_status();
if (staStatus != wifi_stack::WiFiStaStatus::CONNECTED)
{
MESSAGE(TEXT_OTA_NOCONNECTION);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
else
{
std::string serverUrl = stringSettings.otaServerUrl;
if (serverUrl.substr(serverUrl.length() - 4) == ".bin")
{
auto &menuitem = constructMenuItem<VersionMenuItem<TFT_WHITE>>();
std::size_t last_slash_index = serverUrl.find_last_of("/");
auto filename = serverUrl.substr(last_slash_index+1);
auto hash = filename.substr(0, filename.length() - 4);
menuitem.setHash(hash);
menuitem.setUrl(serverUrl);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
else
{
setup_request();
start_descriptor_request(serverUrl);
}
}
}
}
void SelectBuildMenu::update()
{
if(get_request_running())
{
check_descriptor_request();
if (!request_failed.empty())
{
this->buildMenuRequestError(request_failed);
request_failed = {};
}
}
if (parsing_finished)
{
parsing_finished = false;
if (!availableVersions.empty())
{
this->buildMenuFromJson();
}
}
Base::update();
}
void SelectBuildMenu::buildMenuFromJson()
{
auto &latest = constructMenuItem<VersionMenuItem<TFT_GREEN>>();
latest.setHash("latest");
latest.setUrl(url_for_latest);
for (const std::string &hash : availableVersions)
{
auto &menuitem = constructMenuItem<VersionMenuItem<TFT_WHITE>>();
menuitem.setHash(hash);
menuitem.setUrl(fmt::format(url_for_hashes, hash));
}
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void SelectBuildMenu::buildMenuRequestError(std::string error)
{
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>>>();
}
void SelectBuildMenu::back()
{
switchScreen<OtaMenu>();
}
#endif

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

@ -1,151 +1,21 @@
#pragma once
#include <espwifistack.h>
#include <TFT_eSPI.h>
#include "esp_log.h"
#include "fmt/core.h"
// local includes
#include "menudisplay.h"
#include "utils.h"
#include "actions/dummyaction.h"
#include "icons/back.h"
#include "icons/update.h"
#include "texts.h"
#include "buildserver.h"
#include "globals.h"
#define MESSAGE(text) constructMenuItem<makeComponent<MenuItem, StaticText<text>, DefaultFont, StaticColor<TFT_RED>, DummyAction>>()
using namespace espgui;
#ifdef FEATURE_OTA
namespace {
// ToDo: if (request_failed) => MESSAGE("An error occurred")
template<int item_color>
class VersionMenuItem : public MenuItem
{
public:
std::string text() const override { return m_hash; }
void setHash(std::string &&hash) { m_hash = std::move(hash); }
void setHash(const std::string &hash) { m_hash = hash; }
void setUrl(std::string &&url) { m_url = std::move(url); }
void setUrl(const std::string &url) { m_url = url; }
void triggered() override
{
stringSettings.otaUrl = m_url;
saveSettings();
}
int color() const override
{
return item_color;
}
private:
std::string m_url;
std::string m_hash;
};
class SelectBuildMenu :
public MenuDisplay,
public StaticText<TEXT_SELECTBUILD>,
public BackActionInterface<SwitchScreenAction<OtaMenu>>
public espgui::MenuDisplay,
public espgui::StaticText<TEXT_SELECTBUILD>
{
using Base = MenuDisplay;
public:
SelectBuildMenu();
void update() override;
void back() override;
void buildMenuFromJson();
void buildMenuRequestError(std::string error);
SelectBuildMenu()
{
if (count_available_buildserver() < 1)
{
MESSAGE(TEXT_OTA_NOBUILDSERVERAVAILABLE);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
else if (stringSettings.otaServerUrl.empty())
{
MESSAGE(TEXT_OTA_NOBUILDSERVERSELECTED);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
else
{
const auto staStatus = wifi_stack::get_sta_status();
if (staStatus != wifi_stack::WiFiStaStatus::CONNECTED)
{
MESSAGE(TEXT_OTA_NOCONNECTION);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
else
{
std::string serverUrl = stringSettings.otaServerUrl;
if (serverUrl.substr(serverUrl.length() - 4) == ".bin")
{
auto &menuitem = constructMenuItem<VersionMenuItem<TFT_WHITE>>();
std::size_t last_slash_index = serverUrl.find_last_of("/");
auto filename = serverUrl.substr(last_slash_index+1);
auto hash = filename.substr(0, filename.length() - 4);
menuitem.setHash(hash);
menuitem.setUrl(serverUrl);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
else
{
setup_request();
start_descriptor_request(serverUrl);
}
}
}
}
};
void SelectBuildMenu::update()
{
if(get_request_running())
{
check_descriptor_request();
if (!request_failed.empty())
{
this->buildMenuRequestError(request_failed);
request_failed = {};
}
}
if (parsing_finished)
{
parsing_finished = false;
if (!availableVersions.empty())
{
this->buildMenuFromJson();
}
}
Base::update();
}
void SelectBuildMenu::buildMenuFromJson()
{
auto &latest = constructMenuItem<VersionMenuItem<TFT_GREEN>>();
latest.setHash("latest");
latest.setUrl(url_for_latest);
for (const std::string &hash : availableVersions)
{
auto &menuitem = constructMenuItem<VersionMenuItem<TFT_WHITE>>();
menuitem.setHash(hash);
menuitem.setUrl(fmt::format(url_for_hashes, hash));
}
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<OtaMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void SelectBuildMenu::buildMenuRequestError(std::string error)
{
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>>>();
}
} // namespace
#endif

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

@ -0,0 +1,81 @@
#include "timersmenu.h"
// local includes
#include "accessors/settingsaccessors.h"
#include "actions/switchscreenaction.h"
#include "changevaluedisplay.h"
#include "displays/menus/boardcomputerhardwaresettingsmenu.h"
#include "icons/back.h"
#include "texts.h"
using namespace espgui;
namespace {
using PotiReadRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_POTIREADRATE>,
PotiReadRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
using ModeUpdateRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_MODEUPDATERATE>,
ModeUpdateRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
using StatsUpdateRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_STATSUPDATERATE>,
StatsUpdateRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
using DisplayUpdateRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_DISPLAYUPDATERATE>,
DisplayUpdateRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
using DisplayRedrawRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_DISPLAYREDRAWRATE>,
DisplayRedrawRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
#ifdef FEATURE_CAN
using CanReceiveRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_CANRECEIVERATE>,
CanReceiveRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
#endif
}
TimersMenu::TimersMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIREADRATE>, SwitchScreenAction<PotiReadRateChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODEUPDATERATE>, SwitchScreenAction<ModeUpdateRateChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATSUPDATERATE>, SwitchScreenAction<StatsUpdateRateChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYUPDATERATE>, SwitchScreenAction<DisplayUpdateRateChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYREDRAWRATE>, SwitchScreenAction<DisplayRedrawRateChangeDisplay>>>();
#ifdef FEATURE_CAN
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CANRECEIVERATE>, SwitchScreenAction<CanReceiveRateChangeDisplay>>>();
#endif
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void TimersMenu::back()
{
switchScreen<BoardcomputerHardwareSettingsMenu>();
}

76
main/displays/menus/timersmenu.h
View File

@ -1,86 +1,16 @@
#pragma once
// local includes
#include "changevaluedisplay.h"
#include "menudisplay.h"
#include "utils.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
#include "texts.h"
#include "accessors/settingsaccessors.h"
using namespace espgui;
namespace {
class TimersMenu;
using PotiReadRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_POTIREADRATE>,
PotiReadRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
using ModeUpdateRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_MODEUPDATERATE>,
ModeUpdateRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
using StatsUpdateRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_STATSUPDATERATE>,
StatsUpdateRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
using DisplayUpdateRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_DISPLAYUPDATERATE>,
DisplayUpdateRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
using DisplayRedrawRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_DISPLAYREDRAWRATE>,
DisplayRedrawRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
#ifdef FEATURE_CAN
using CanReceiveRateChangeDisplay = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_CANRECEIVERATE>,
CanReceiveRateAccessor,
BackActionInterface<SwitchScreenAction<TimersMenu>>,
SwitchScreenAction<TimersMenu>
>;
#endif
class TimersMenu :
public MenuDisplay,
public StaticText<TEXT_TIMERS>,
public BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>
public StaticText<TEXT_TIMERS>
{
public:
TimersMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_POTIREADRATE>, SwitchScreenAction<PotiReadRateChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MODEUPDATERATE>, SwitchScreenAction<ModeUpdateRateChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATSUPDATERATE>, SwitchScreenAction<StatsUpdateRateChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYUPDATERATE>, SwitchScreenAction<DisplayUpdateRateChangeDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISPLAYREDRAWRATE>, SwitchScreenAction<DisplayRedrawRateChangeDisplay>>>();
#ifdef FEATURE_CAN
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CANRECEIVERATE>, SwitchScreenAction<CanReceiveRateChangeDisplay>>>();
#endif
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<BoardcomputerHardwareSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
TimersMenu();
void back() override;
};
} // namespace

123
main/displays/menus/wifiscanmenu.cpp
View File

@ -0,0 +1,123 @@
#include "wifiscanmenu.h"
// system includes
#include <optional>
// esp-idf includes
#include <esp_log.h>
// 3rdparty lib includes
#include <espchrono.h>
#include <espwifistack.h>
#include <fmt/core.h>
// local includes
#include "menudisplay.h"
#include "utils.h"
#include "actions/multiaction.h"
#include "actions/switchscreenaction.h"
#include "actions/dummyaction.h"
#include "icons/back.h"
#include "texts.h"
#include "wifi_bobbycar.h"
using namespace std::chrono_literals;
using namespace espgui;
WifiScanMenu::WifiScanMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<StationWifiSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string WifiScanMenu::text() const
{
const auto scanStatus = wifi_stack::get_scan_status();
auto text = wifi_stack::toString(scanStatus);
if (scanStatus != wifi_stack::WiFiScanStatus::Scanning)
if (const auto &result = wifi_stack::get_scan_result())
text += fmt::format(" ({} found)", result->entries.size());
return text;
}
void WifiScanMenu::start()
{
Base::start();
m_lastScanComplete = {};
if (wifi_stack::get_scan_status() != wifi_stack::WiFiScanStatus::Scanning)
if (const auto result = wifi_scan(); result != ESP_OK)
ESP_LOGE("BOBBY", "wifi_scan() failed with %s", esp_err_to_name(result));
}
void WifiScanMenu::update()
{
if (wifi_stack::get_scan_status() == wifi_stack::WiFiScanStatus::Scanning)
{
// TODO
}
else
{
const auto now = espchrono::millis_clock::now();
if (!m_lastScanComplete)
{
const auto &result = wifi_stack::get_scan_result();
auto backButton = takeLastMenuItem();
for (std::size_t i = 0; i < (result ? result->entries.size() : 0); i++)
{
std::string ssid{reinterpret_cast<const char*>(result->entries[i].ssid)};
if (menuItemCount() <= i)
{
if (m_reusableItems.empty())
{
auto &item = constructMenuItem<makeComponent<MenuItem, ChangeableText, DummyAction>>();
item.setTitle(std::move(ssid));
}
else
{
std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>> ptr = std::move(m_reusableItems.back());
m_reusableItems.pop_back();
ptr->setTitle(std::move(ssid));
emplaceMenuItem(std::move(ptr));
}
}
else
{
auto &item = *(makeComponent<MenuItem, ChangeableText, DummyAction>*)(&getMenuItem(i));
item.setTitle(std::move(ssid));
}
}
while (menuItemCount() > (result ? result->entries.size() : 0))
m_reusableItems.emplace_back((makeComponent<MenuItem, ChangeableText, DummyAction>*)takeLastMenuItem().release());
emplaceMenuItem(std::move(backButton));
m_lastScanComplete = now;
}
else if (espchrono::ago(*m_lastScanComplete) >= 10s)
{
m_lastScanComplete = {};
if (const auto result = wifi_scan(); result != ESP_OK)
ESP_LOGE("BOBBY", "wifi_scan() failed with %s", esp_err_to_name(result));
}
}
Base::update();
}
void WifiScanMenu::stop()
{
wifi_stack::delete_scan_result();
}
void WifiScanMenu::back()
{
switchScreen<StationWifiSettingsMenu>();
}

122
main/displays/menus/wifiscanmenu.h
View File

@ -1,139 +1,27 @@
#pragma once
// system includes
#include <optional>
// esp-idf includes
#include <esp_log.h>
// 3rdparty lib includes
#include <espchrono.h>
#include <espwifistack.h>
#include <fmt/core.h>
// local includes
#include "menudisplay.h"
#include "utils.h"
#include "actions/multiaction.h"
#include "actions/switchscreenaction.h"
#include "actions/dummyaction.h"
#include "icons/back.h"
#include "actions/switchscreenaction.h"
#include "displays/menus/stationwifisettingsmenu.h"
#include "menudisplay.h"
#include "texts.h"
#include "wifi_bobbycar.h"
#include "utils.h"
using namespace std::chrono_literals;
using namespace espgui;
namespace {
class WifiScanMenu : public MenuDisplay, public BackActionInterface<SwitchScreenAction<StationWifiSettingsMenu>>
{
using Base = MenuDisplay;
public:
WifiScanMenu();
std::string text() const override;
void start() override;
void update() override;
void stop() override;
void back() override;
private:
std::optional<espchrono::millis_clock::time_point> m_lastScanComplete;
std::vector<std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>>> m_reusableItems;
};
WifiScanMenu::WifiScanMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<StationWifiSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
std::string WifiScanMenu::text() const
{
const auto scanStatus = wifi_stack::get_scan_status();
auto text = wifi_stack::toString(scanStatus);
if (scanStatus != wifi_stack::WiFiScanStatus::Scanning)
if (const auto &result = wifi_stack::get_scan_result())
text += fmt::format(" ({} found)", result->entries.size());
return text;
}
void WifiScanMenu::start()
{
Base::start();
m_lastScanComplete = {};
if (wifi_stack::get_scan_status() != wifi_stack::WiFiScanStatus::Scanning)
if (const auto result = wifi_scan(); result != ESP_OK)
ESP_LOGE("BOBBY", "wifi_scan() failed with %s", esp_err_to_name(result));
}
void WifiScanMenu::update()
{
if (wifi_stack::get_scan_status() == wifi_stack::WiFiScanStatus::Scanning)
{
// TODO
}
else
{
const auto now = espchrono::millis_clock::now();
if (!m_lastScanComplete)
{
const auto &result = wifi_stack::get_scan_result();
auto backButton = takeLastMenuItem();
for (std::size_t i = 0; i < (result ? result->entries.size() : 0); i++)
{
std::string ssid{reinterpret_cast<const char*>(result->entries[i].ssid)};
if (menuItemCount() <= i)
{
if (m_reusableItems.empty())
{
auto &item = constructMenuItem<makeComponent<MenuItem, ChangeableText, DummyAction>>();
item.setTitle(std::move(ssid));
}
else
{
std::unique_ptr<makeComponent<MenuItem, ChangeableText, DummyAction>> ptr = std::move(m_reusableItems.back());
m_reusableItems.pop_back();
ptr->setTitle(std::move(ssid));
emplaceMenuItem(std::move(ptr));
}
}
else
{
auto &item = *(makeComponent<MenuItem, ChangeableText, DummyAction>*)(&getMenuItem(i));
item.setTitle(std::move(ssid));
}
}
while (menuItemCount() > (result ? result->entries.size() : 0))
m_reusableItems.emplace_back((makeComponent<MenuItem, ChangeableText, DummyAction>*)takeLastMenuItem().release());
emplaceMenuItem(std::move(backButton));
m_lastScanComplete = now;
}
else if (espchrono::ago(*m_lastScanComplete) >= 10s)
{
m_lastScanComplete = {};
if (const auto result = wifi_scan(); result != ESP_OK)
ESP_LOGE("BOBBY", "wifi_scan() failed with %s", esp_err_to_name(result));
}
}
Base::update();
}
void WifiScanMenu::stop()
{
wifi_stack::delete_scan_result();
}
} // namespace

5
main/displays/statusdisplay.cpp
View File

@ -14,6 +14,7 @@
#endif
#include "drivingstatistics.h"
#include "udpcloud.h"
#include "modes/defaultmode.h"
using namespace espgui;
@ -69,6 +70,10 @@ void StatusDisplay::initScreen()
void StatusDisplay::redraw()
{
Base::redraw();
if (modes::defaultMode.overrideHandbremse)
tft.fillRect(0, 0, tft.width(), 2, TFT_RED);
else
tft.fillRect(0, 0, tft.width(), 2, TFT_BLACK);
tft.setTextFont(2);
m_labelRawGas.redraw(raw_gas ? std::to_string(*raw_gas) : "?");

13
main/handbremse.h Normal file
View File

@ -0,0 +1,13 @@
#pragma once
// system
#include <cstdint>
// 3rdparty lib includes
#include <cpptypesafeenum.h>
#define HandbremseModeValues(x) \
x(MOSFETS_OFF) \
x(OPENMODE) \
x(SPEED_0)
DECLARE_TYPESAFE_ENUM(HandbremseMode, : uint8_t, HandbremseModeValues)

181
main/modes/defaultmode.cpp
View File

@ -50,104 +50,133 @@ void DefaultMode::update()
const auto now = espchrono::millis_clock::now();
float pwm;
if (gas_processed >= settings.defaultMode.add_schwelle)
if (gas_processed > 10 || (!overrideHandbremse && (abs(avgSpeedKmh) > 2 || !controllers.front.feedbackValid || !controllers.back.feedbackValid || settings.handbremse.triggerTimeout < 1 || !settings.handbremse.enable || !settings.handbremse.automatic)))
{
pwm = (gas_processed/1000.*settings.defaultMode.gas1_wert) + (brems_processed/1000.*settings.defaultMode.brems1_wert);
m_stillSince = std::nullopt;
overrideHandbremse = false;
goto hell;
}
else if (!overrideHandbremse && !m_stillSince)
{
m_stillSince = now;
goto hell;
}
else if ((overrideHandbremse && abs(avgSpeedKmh) <= 2) && espchrono::ago(*m_stillSince) >= espchrono::milliseconds32(settings.handbremse.triggerTimeout))
{
fixCommonParams();
if ((settings.defaultMode.enableSmoothingUp || settings.defaultMode.enableSmoothingDown) && (pwm > 1000. || lastPwm > 1000.))
for (bobbycar::protocol::serial::MotorState &motor : motors())
{
if (lastPwm < pwm && settings.defaultMode.enableSmoothingUp)
{
pwm = std::min(pwm, lastPwm + (settings.defaultMode.smoothing * std::chrono::milliseconds{now - lastTime}.count() / 100.f));
if (pwm < 1000.)
pwm = 1000.;
}
else if (lastPwm > pwm && settings.defaultMode.enableSmoothingDown)
{
pwm = std::max(pwm, lastPwm - (settings.defaultMode.smoothing * std::chrono::milliseconds{now - lastTime}.count() / 100.f));
}
motor.ctrlTyp = bobbycar::protocol::ControlType::FieldOrientedControl;
motor.ctrlMod = ((settings.handbremse.mode == HandbremseMode::SPEED_0) ? bobbycar::protocol::ControlMode::Speed : bobbycar::protocol::ControlMode::OpenMode);
motor.pwm = 0;
motor.cruiseCtrlEna = false;
motor.nCruiseMotTgt = 0;
if (settings.handbremse.mode == HandbremseMode::MOSFETS_OFF)
motor.enable = false;
}
}
else
{
pwm = (gas_processed/1000.*settings.defaultMode.gas2_wert) - (brems_processed/1000.*settings.defaultMode.brems2_wert);
if (
(settings.defaultMode.enableFieldWeakSmoothingUp || settings.defaultMode.enableFieldWeakSmoothingDown) &&
(lastPwm > settings.defaultMode.fwSmoothLowerLimit) &&
brems_processed > 0)
hell:
float pwm;
if (gas_processed >= settings.defaultMode.add_schwelle)
{
if (lastPwm < pwm && settings.defaultMode.enableFieldWeakSmoothingUp)
{
auto effective_smoothing = settings.defaultMode.smoothing;
auto difference_to_target = std::abs(pwm-lastPwm);
effective_smoothing *= std::max((difference_to_target / 500),0.5f);
pwm = (gas_processed/1000.*settings.defaultMode.gas1_wert) + (brems_processed/1000.*settings.defaultMode.brems1_wert);
pwm = std::min(pwm, lastPwm + (effective_smoothing * std::chrono::milliseconds{now - lastTime}.count() / 100.f));
}
else if (lastPwm > pwm && settings.defaultMode.enableFieldWeakSmoothingDown)
if ((settings.defaultMode.enableSmoothingUp || settings.defaultMode.enableSmoothingDown) && (pwm > 1000. || m_lastPwm > 1000.))
{
auto effective_smoothing = settings.defaultMode.smoothing;
auto difference_to_target = std::abs(pwm-lastPwm);
effective_smoothing *= std::max((difference_to_target / 500),0.5f);
pwm = std::max(pwm, lastPwm - (effective_smoothing * std::chrono::milliseconds{now - lastTime}.count() / 100.f));
if (m_lastPwm < pwm && settings.defaultMode.enableSmoothingUp)
{
pwm = std::min(pwm, m_lastPwm + (settings.defaultMode.smoothing * std::chrono::milliseconds{now - m_lastTime}.count() / 100.f));
if (pwm < 1000.)
pwm = 1000.;
}
else if (m_lastPwm > pwm && settings.defaultMode.enableSmoothingDown)
{
pwm = std::max(pwm, m_lastPwm - (settings.defaultMode.smoothing * std::chrono::milliseconds{now - m_lastTime}.count() / 100.f));
}
}
}
}
lastPwm = pwm;
lastTime = now;
auto pair = split(settings.defaultMode.modelMode);
if (settings.hybrid.enable)
{
auto activationLimit = settings.hybrid.activationLimit;
auto deactivationLimit = settings.hybrid.deactivationLimit;
auto diff = std::abs(activationLimit - deactivationLimit);
if (diff < 20)
else
{
int half = (diff / 2) + 0.5;
deactivationLimit -= half;
activationLimit += half;
pwm = (gas_processed/1000.*settings.defaultMode.gas2_wert) - (brems_processed/1000.*settings.defaultMode.brems2_wert);
if (
(settings.defaultMode.enableFieldWeakSmoothingUp || settings.defaultMode.enableFieldWeakSmoothingDown) &&
(m_lastPwm > settings.defaultMode.fwSmoothLowerLimit) &&
brems_processed > 0)
{
if (m_lastPwm < pwm && settings.defaultMode.enableFieldWeakSmoothingUp)
{
auto effective_smoothing = settings.defaultMode.smoothing;
auto difference_to_target = std::abs(pwm-m_lastPwm);
effective_smoothing *= std::max((difference_to_target / 500),0.5f);
pwm = std::min(pwm, m_lastPwm + (effective_smoothing * std::chrono::milliseconds{now - m_lastTime}.count() / 100.f));
}
else if (m_lastPwm > pwm && settings.defaultMode.enableFieldWeakSmoothingDown)
{
auto effective_smoothing = settings.defaultMode.smoothing;
auto difference_to_target = std::abs(pwm-m_lastPwm);
effective_smoothing *= std::max((difference_to_target / 500),0.5f);
pwm = std::max(pwm, m_lastPwm - (effective_smoothing * std::chrono::milliseconds{now - m_lastTime}.count() / 100.f));
}
}
}
if (!hybridModeActivated && (pwm > activationLimit))
m_lastPwm = pwm;
m_lastTime = now;
auto pair = split(settings.defaultMode.modelMode);
if (settings.hybrid.enable)
{
hybridModeActivated = true;
}
else if (hybridModeActivated && (pwm < deactivationLimit))
{
hybridModeActivated = false;
auto activationLimit = settings.hybrid.activationLimit;
auto deactivationLimit = settings.hybrid.deactivationLimit;
auto diff = std::abs(activationLimit - deactivationLimit);
if (diff < 20)
{
int half = (diff / 2) + 0.5;
deactivationLimit -= half;
activationLimit += half;
}
if (!hybridModeActivated && (pwm > activationLimit))
{
hybridModeActivated = true;
}
else if (hybridModeActivated && (pwm < deactivationLimit))
{
hybridModeActivated = false;
}
if (hybridModeActivated)
{
pair = split(settings.hybrid.hybridMode);
}
}
if (hybridModeActivated)
for (bobbycar::protocol::serial::MotorState &motor : motorsInController(controllers.front))
{
pair = split(settings.hybrid.hybridMode);
motor.ctrlTyp = pair.first;
motor.ctrlMod = pair.second;
motor.pwm = pwm / 100. * settings.defaultMode.frontPercentage;
motor.cruiseCtrlEna = false;
motor.nCruiseMotTgt = 0;
}
for (bobbycar::protocol::serial::MotorState &motor : motorsInController(controllers.back))
{
motor.ctrlTyp = pair.first;
motor.ctrlMod = pair.second;
motor.pwm = pwm / 100. * settings.defaultMode.backPercentage;
motor.cruiseCtrlEna = false;
motor.nCruiseMotTgt = 0;
}
}
for (bobbycar::protocol::serial::MotorState &motor : motorsInController(controllers.front))
{
motor.ctrlTyp = pair.first;
motor.ctrlMod = pair.second;
motor.pwm = pwm / 100. * settings.defaultMode.frontPercentage;
motor.cruiseCtrlEna = false;
motor.nCruiseMotTgt = 0;
}
for (bobbycar::protocol::serial::MotorState &motor : motorsInController(controllers.back))
{
motor.ctrlTyp = pair.first;
motor.ctrlMod = pair.second;
motor.pwm = pwm / 100. * settings.defaultMode.backPercentage;
motor.cruiseCtrlEna = false;
motor.nCruiseMotTgt = 0;
}
fixCommonParams();
}
fixCommonParams();
sendCommands();
}

7
main/modes/defaultmode.h
View File

@ -2,6 +2,7 @@
// system includes
#include <cstdint>
#include <optional>
// 3rdparty lib includes
#include <espchrono.h>
@ -24,10 +25,12 @@ public:
bool waitForGasLoslass{false};
bool waitForBremsLoslass{false};
bool hybridModeActivated{false};
bool overrideHandbremse{false};
private:
espchrono::millis_clock::time_point lastTime{espchrono::millis_clock::now()};
float lastPwm{0};
espchrono::millis_clock::time_point m_lastTime{espchrono::millis_clock::now()};
float m_lastPwm{0};
std::optional<espchrono::millis_clock::time_point> m_stillSince;
};
namespace modes {

8
main/presets.h
View File

@ -235,6 +235,13 @@ constexpr Settings::MotortestMode defaultMotortestMode {
.maxPwm = 400
};
constexpr Settings::Handbremse defaultHandbremse {
.mode = HandbremseMode::MOSFETS_OFF,
.triggerTimeout = 10,
.automatic = false,
.enable = false
};
#ifdef FEATURE_LEDSTRIP
constexpr Settings::Ledstrip defaultLedstrip {
.enableLedAnimation = true,
@ -320,6 +327,7 @@ constexpr Settings defaultSettings {
.hybrid = defaultHybrid,
.lockscreen = defaultLockscreen,
.savedStatistics = defaultSavedStatistics,
.handbremse = defaultHandbremse
};
StringSettings makeDefaultStringSettings();

14
main/settings.h
View File

@ -21,6 +21,7 @@
#include "bluetoothmode.h"
#endif
#include "unifiedmodelmode.h"
#include "handbremse.h"
#include "ledstrip.h"
enum class LarsmModeMode : uint8_t { Mode1, Mode2, Mode3, Mode4 };
@ -214,6 +215,13 @@ struct Settings
uint32_t totalCentimeters;
} savedStatistics;
struct Handbremse {
HandbremseMode mode;
uint16_t triggerTimeout;
bool automatic;
bool enable;
} handbremse;
template<typename T>
void executeForEveryCommonSetting(T &&callable);
@ -341,7 +349,13 @@ void Settings::executeForEveryCommonSetting(T &&callable)
callable("lockAlwPresetSw", lockscreen.allowPresetSwitch);
callable("lockscreenPin", lockscreen.pin);
callable("totalCentimeter", savedStatistics.totalCentimeters);
callable("handBremsE", handbremse.enable);
callable("handBremsA", handbremse.automatic);
callable("handBremsM", handbremse.mode);
callable("handBremsT", handbremse.triggerTimeout);
}
template<typename T>

12
main/settingspersister.cpp
View File

@ -189,6 +189,14 @@ template<> struct nvsGetterHelper<UnifiedModelMode> { static esp_err_t nvs_get(n
*out_value = UnifiedModelMode(tempValue);
return err;
}};
template<> struct nvsGetterHelper<HandbremseMode> { static esp_err_t nvs_get(nvs_handle handle, const char* key, HandbremseMode* out_value)
{
uint8_t tempValue;
esp_err_t err = nvs_get_u8(handle, key, &tempValue);
if (err == ESP_OK)
*out_value = HandbremseMode(tempValue);
return err;
}};
#if defined(FEATURE_LEDSTRIP) && defined(FEATURE_OTA)
template<> struct nvsGetterHelper<OtaAnimationModes> { static esp_err_t nvs_get(nvs_handle handle, const char* key, OtaAnimationModes* out_value)
{
@ -355,6 +363,10 @@ template<> struct nvsSetterHelper<UnifiedModelMode> { static esp_err_t nvs_set(n
{
return nvs_set_u8(handle, key, uint8_t(value));
}};
template<> struct nvsSetterHelper<HandbremseMode> { static esp_err_t nvs_set(nvs_handle handle, const char* key, HandbremseMode value)
{
return nvs_set_u8(handle, key, uint8_t(value));
}};
#if defined(FEATURE_LEDSTRIP) && defined(FEATURE_OTA)
template<> struct nvsSetterHelper<OtaAnimationModes> { static esp_err_t nvs_set(nvs_handle handle, const char* key, OtaAnimationModes value)
{

535
main/texts.cpp
View File

@ -0,0 +1,535 @@
#include "texts.h"
namespace bobbytexts {
//AboutMenu
char TEXT_ABOUT[] = "About";
char TEXT_BACK[] = "Back";
//AccessPointWifiSettingsMenu
char TEXT_ACCESSPOINTWIFISETTINGS[] = "Access Point WiFi settings";
char TEXT_WIFIAPENABLED[] = "AP enabled";
char TEXT_RESEND_DNS[] = "Resend DNS";
//char TEXT_BACK[] = "Back";
#ifdef TEXTS_PLUGIN
#include TEXTS_PLUGIN
#endif
#ifdef FEATURE_BLUETOOTH
//BluetoothSettingsMenu
char TEXT_BLUETOOTHSETTINGS[] = "Bluetooth settings";
char TEXT_BLUETOOTHBEGIN[] = "begin()";
char TEXT_BLUETOOTHBEGINMASTER[] = "begin() Master";
char TEXT_BLUETOOTHFLUSH[] = "flush()";
char TEXT_BLUETOOTHEND[] = "end()";
char TEXT_BLUETOOTHDISCONNECT[] = "disconnect()";
char TEXT_AUTOBLUETOOTHMODE[] = "Auto bluetooth mode";
//char TEXT_BACK[] = "Back";
//BmsMenu
#ifdef FEATURE_BMS
char TEXT_BMS[] = "BMS";
char TEXT_CONNECTBMS[] = "Connect BMS";
char TEXT_DISCONNECTBMS[] = "Disonnect BMS";
char TEXT_TURNONCHARGE[] = "Turn on charge";
char TEXT_TURNOFFCHARGE[] = "Turn off charge";
char TEXT_TURNONDISCHARGE[] = "Turn on discharge";
char TEXT_TURNOFFDISCHARGE[] = "Turn off discharge";
//char TEXT_BACK[] = "Back";
#endif
#endif
#ifdef FEATURE_BLE
//BleSettingsMenu
char TEXT_BLESETTINGS[] = "BLE settings";
char TEXT_BLEENABLED[] = "BLE enabled";
//char TEXT_BACK[] = "Back";
#endif
#ifdef FEATURE_CLOUD
//CloudSettingsMenu
char TEXT_CLOUDSETTINGS[] = "Cloud settings";
char TEXT_CLOUDENABLED[] = "Tcp Cloud enabled";
char TEXT_UDPCLOUDENABLED[] = "Udp Cloud enabled";
char TEXT_CLOUDTRANSMITTIMEOUT[] = "Transmit timeout";
char TEXT_CLOUDCOLLECTRATE[] = "Cloud collect rate";
char TEXT_CLOUDSENDRATE[] = "Cloud send rate";
char TEXT_UDPSENDRATE[] = "Udp send rate";
char TEXT_UDPUSESTRING[] = "Udp use std::string";
//char TEXT_BACK[] = "Back";
#endif
//DebugMenu
char TEXT_LOADSETTINGS[] = "Load settings";
char TEXT_SAVESETTINGS[] = "Save settings";
char TEXT_ERASENVS[] = "Erase NVS";
char TEXT_FRONTCOMMAND[] = "Front command";
char TEXT_BACKCOMMAND[] = "Back command";
char TEXT_FRONTLEFTCOMMAND[] = "Front left command";
char TEXT_FRONTRIGHTCOMMAND[] = "Front right command";
char TEXT_BACKLEFTCOMMAND[] = "Back left command";
char TEXT_BACKRIGHTCOMMAND[] = "Back right command";
char TEXT_FRONTFEEDBACK[] = "Front feedback";
char TEXT_BACKFEEDBACK[] = "Back feedback";
char TEXT_FRONTLEFTFEEDBACK[] = "Front left feedback";
char TEXT_FRONTRIGHTFEEDBACK[] = "Front right feedback";
char TEXT_BACKLEFTFEEDBACK[] = "Back left feedback";
char TEXT_BACKRIGHTFEEDBACK[] = "Back right feedback";
//char TEXT_BACK[] = "Back";
//MainMenu
char TEXT_MAINMENU[] = "Main menu";
char TEXT_STATUS[] = "Status";
char TEXT_SELECTMODE[] = "Select mode";
char TEXT_MODESETTINGS[] = "Mode settings";
char TEXT_PRESETS[] = "Presets";
char TEXT_PROFILES[] = "Profiles";
char TEXT_GRAPHS[] = "Graphs";
//char TEXT_BMS[] = "BMS";
char TEXT_SETTINGS[] = "Settings";
char TEXT_LOCKVEHICLE[] = "Lock vehicle";
char TEXT_MOSFETS[] = "Mosfets";
char TEXT_DEMOS[] = "Demos";
char TEXT_GARAGE[] = "Garage";
char TEXT_UPDATE[] = "Update";
char TEXT_POWEROFF[] = "Poweroff";
char TEXT_REBOOT[] = "Reboot";
char TEXT_DEBUG[] = "Debug";
char TEXT_BATTERY[] = "Battery";
char TEXT_BATTERYDEBUG[] = "Bat Debug Menu";
char TEXT_TOGGLECLOUDDEBUG[] = "Cloud Debug";
//BatteryMenu
char TEXT_CELL_SERIES[] = "Cells (Series)";
char TEXT_CELL_PARALLEL[] = "Cells (Parallel)";
char TEXT_SELECT_CELL_TYPE[] = "Select Cell Type";
char TEXT_CELL_TYPE[] = "Cell Type";
char TEXT_BATTERY_CALIBRATE[] = "Calibrate Voltages";
char TEXT_BATTERY_TYPE_22P[] = "22P cells";
char TEXT_BATTERY_TYPE_HG2[] = "HG2 cells";
char TEXT_BATTERY_TYPE_MH1[] = "MH1 cells";
char TEXT_BATTERY_TYPE_VTC5[] = "VTC5 cells";
char TEXT_BATTERY_TYPE_BAK_25R[] = "BAK / 25R cells";
char TEXT_BATTERY_WHKM[] = "Wh per km";
char TEXT_BATTERY_APPLYCALIB[] = "Apply calibration";
char TEXT_VOLTAGECALIBRATION_RESET[] = "Reset calibration";
//CalibrateVoltageDisplay
char TEXT_VOLTAGECALIBRATION_30V[] = "Calibrate 30.0V";
char TEXT_VOLTAGECALIBRATION_50V[] = "Calibrate 50.0V";
char TEXT_VOLTAGECALIBRATION_VALUE_30_FRONT[] = "30V Front";
char TEXT_VOLTAGECALIBRATION_VALUE_30_BACK[] = "30V Back";
char TEXT_VOLTAGECALIBRATION_VALUE_50_FRONT[] = "50V Front";
char TEXT_VOLTAGECALIBRATION_VALUE_50_BACK[] = "50V Back";
//SettingsMenu
//char TEXT_SETTINGS[] = "Settings";
char TEXT_BACKLIGHT[] = "Backlight";
char TEXT_LIMITSSETTINGS[] = "Limits settings";
char TEXT_WIFISETTINGS[] = "WiFi settings";
//char TEXT_BLUETOOTHSETTINGS[] = "Bluetooth settings";
//char TEXT_BLESETTINGS[] = "BLE settings";
//char TEXT_CLOUDSETTINGS[] = "Cloud settings";
char TEXT_TIME[] = "Time";
char TEXT_MODESSETTINGS[] = "Modes settings";
char TEXT_CONTROLLERHARDWARESETTINGS[] = "Controller H/W settings";
char TEXT_BOARDCOMPUTERHARDWARESETTINGS[] = "Boardcomputer H/W settings";
char TEXT_AUTOCONNECTBMS[] = "Auto connect BMS";
char TEXT_BUZZER[] = "Buzzer";
char TEXT_FRONTLED[] = "Front LED";
char TEXT_BACKLED[] = "Back LED";
//char TEXT_ABOUT[] = "About";
//char TEXT_BACK[] = "Back";
//ControllerHardwareSettings
//char TEXT_CONTROLLERHARDWARESETTINGS[] = "Controller H/W settings";
char TEXT_WHEELDIAMETERMM[] = "Wheel diameter (mm)";
char TEXT_WHEELDIAMETERINCH[] = "Wheel diameter (inch)";
char TEXT_NUMMAGNETPOLES[] = "Num magnet poles";
char TEXT_SETENABLED[] = "Set enabled";
char TEXT_SETINVERTED[] = "Set inverted";
char TEXT_SWAPFRONTBACK[] = "Swap front/back";
#ifdef FEATURE_CAN
char TEXT_FRONTSENDCAN[] = "Front send CAN";
char TEXT_BACKSENDCAN[] = "Back send CAN";
char TEXT_CANTRANSMITTIMEOUT[] = "CanTransmitTimeout";
char TEXT_CANRECEIVETIMEOUT[] = "CanReceiveTimeout";
#endif
//char TEXT_BACK[] = "Back";
//StationWifiSettingsMenu
char TEXT_STATIONWIFISETTINGS[] = "Station WiFi settings";
char TEXT_WIFISTAENABLED[] = "STA enabled";
char TEXT_WIFITRIGGERSCAN[] = "Trigger Scan";
char TEXT_WIFISCANRESULTS[] = "WiFi scan results";
//char TEXT_BACK[] = "Back";
//DemosMenu
//char TEXT_DEMOS[] = "Demos";
char TEXT_STARFIELD[] = "Starfield";
char TEXT_PINGPONG[] = "PingPong";
char TEXT_SPIRO[] = "Spiro";
char TEXT_GAMEOFLIFE[] = "GameOfLife";
//char TEXT_BACK[] = "Back";
//BuzzerMenu
//char TEXT_BUZZER[] = "Buzzer";
char TEXT_FRONTFREQ[] = "Front freq";
char TEXT_FRONTPATTERN[] = "Front pattern";
char TEXT_BACKFREQ[] = "Back freq";
char TEXT_BACKPATTERN[] = "Back pattern";
char TEXT_REVERSEBEEP[] = "Reverse beep";
char TEXT_REVERSEBEEPFREQ0[] = "Reverse beep freq0";
char TEXT_REVERSEBEEPFREQ1[] = "Reverse beep freq1";
char TEXT_REVERSEBEEPDURATION0[] = "Reverse beep duration0";
char TEXT_REVERSEBEEPDURATION1[] = "Reverse beep duration1";
//char TEXT_BACK[] = "Back";
//LimitsSettingsMenu
//char TEXT_LIMITSSETTINGS[] = "Limit settings";
char TEXT_IMOTMAX[] = "iMotMax";
char TEXT_IDCMAX[] = "iDcMax";
char TEXT_NMOTMAXKMH[] = "nMotMaxKmh";
char TEXT_NMOTMAX[] = "nMotMax";
char TEXT_FIELDWEAKMAX[] = "fldWkMax";
char TEXT_PHASEADVMAX[] = "phsAdvMax";
//char TEXT_BACK[] = "Back";
//DebugMenu
//char TEXT_DEBUG[] = "Debug";
char TEXT_DYNAMICMENU[] = "Dynamic menu";
//char TEXT_BACK[] = "Back";
//DefaultModeSettingsMenu
//char TEXT_DEFAULTMODESETTINGS[] = "Default mode settings";
char TEXT_MODELMODE[] = "Model mode";
char TEXT_HYBRIDMODE[] = "Hybrid mode";
char TEXT_SQUAREGAS[] = "Square gas";
char TEXT_SQUAREBREMS[] = "Square brems";
char TEXT_ENABLESMOOTHINGUP[] = "Enable up smoothing";
char TEXT_ENABLESMOOTHINGDOWN[] = "Enable down smoothing";
char TEXT_ENABLEFWSMOOTHINGUP[] = "Enable fw up smoothing";
char TEXT_ENABLEFWSMOOTHINGDOWN[] = "Enable fw down smoothing";
char TEXT_FWSMOOTHING_LIMIT[] = "Fw smooth lower limit";
char TEXT_SMOOTHINGVAL[] = "Smoothing";
char TEXT_FRONTPERCENTAGE[] = "Front %";
char TEXT_BACKPERCENTAGE[] = "Back %";
char TEXT_ADDSCHWELLE[] = "Add/Sub Lim";
char TEXT_SUBGASVAL[] = "Add Gas";
char TEXT_SUBBRAKEVAL[] = "Add Brake";
char TEXT_ADDGASVAL[] = "Sub Gas";
char TEXT_ADDBRAKEVAL[] = "Sub Brake";
char TEXT_HYBRIDENABLE[] = "Enable Hybrid mode";
char TEXT_HYBRIDACTIVATIONLIMIT[] = "Hybrid activation-limit";
char TEXT_HYBRIDDEACTIVATIONLIMIT[] = "Hybrid deactivation-limit";
char TEXT_LIMITS_TO_NEAR[] = "Hybrid limits too near (>20)";
char TEXT_HANDBREMSE_ENABLE[] = "Enable Handbrems";
char TEXT_HANDBREMSE_AUTOMATIC[] = "Automatic Handbrems";
char TEXT_HANDBREMSE_MODE[] = "Handbrems Mode";
char TEXT_HANDBREMSE_TRIGGERTIMEOUT[] = "Handbrems Timeout";
//char TEXT_BACK[] = "Back";
//DynamicDebugMenu
//char TEXT_DYNAMICMENU[] = "Dynamic menu";
//char TEXT_BACK[] = "Back";
//EnableMenu
//char TEXT_SETENABLED[] = "Set enabled";
char TEXT_ENABLEFRONTLEFT[] = "Enable front left";
char TEXT_ENABLEFRONTRIGHT[] = "Enable front right";
char TEXT_ENABLEBACKLEFT[] = "Enable back left";
char TEXT_ENABLEBACKRIGHT[] = "Enable back right";
//char TEXT_BACK[] = "Back";
//GametrakModeSettingsMenu
char TEXT_GAMETRAKMODESETTINGS[] = "Gametrak mode settings";
//GenericWifiSettingsMenu
char TEXT_GENERICWIFISETTINGS[] = "Generic WiFi settings";
//char TEXT_BACK[] = "Back";
//GraphsMenu
//char TEXT_GRAPHS[] = "Graphs";
char TEXT_GAS[] = "Gas";
char TEXT_BREMS[] = "Brems";
char TEXT_POTIS[] = "Potis";
char TEXT_AVGSPEED[] = "Avg. speed";
char TEXT_AVGSPEEDKMH[] = "Avg. speed KMH";
char TEXT_SUMCURRENT[] = "Sum current";
char TEXT_FRONTVOLTAGE[] = "Front voltage";
char TEXT_BACKVOLTAGE[] = "Back voltage";
char TEXT_VOLTAGES[] = "Voltages";
char TEXT_BMSVOLTAGE[] = "BMS voltage";
char TEXT_BMSCURRENT[] = "BMS current";
char TEXT_BMSPOWER[] = "BMS power";
char TEXT_SUMCURRENTSCOMPARISON[] = "Sum currents comparison";
char TEXT_MOTORCURRENTS[] = "Motor currents";
char TEXT_RSSI[] = "RSSI";
//char TEXT_BACK[] = "Back";
//InvertMenu
//char TEXT_SETINVERTED[] = "Set inverted";
char TEXT_INVERTFRONTLEFT[] = "Invert front left";
char TEXT_INVERTFRONTRIGHT[] = "Invert front right";
char TEXT_INVERTBACKLEFT[] = "Invert back left";
char TEXT_INVERTBACKRIGHT[] = "Invert back right";
//char TEXT_BACK[] = "Back";
//LarsmModeSettingsMenu
char TEXT_LARSMMODESETTINGS[] = "Larsm mode settings";
//char TEXT_MODELMODE[] = "Model mode";
char TEXT_SETMODE[] = "Set mode";
char TEXT_SETITERATIONS[] = "Set iterations";
//char TEXT_BACK[] = "Back";
//MotortestModeSettingsMenu
char TEXT_MOTORTESTMODESETTINGS[] = "Motortest mode seetings";
char TEXT_MOTORTESTMAXPWM[] = "Max Pwm";
char TEXT_MOTORTESTMULTIPLIKATOR[] = "Acceleration";
//LedstripMenu
char TEXT_LEDSTRIP[] = "Ledstrip";
char TEXT_LEDANIMATION[] = "LED Animation";
char TEXT_BRAKELIGHTS[] = "Brake Lights";
char TEXT_BLINKANIMATION[] = "Blink animation";
char TEXT_ANIMATION_TYPE[] = "Blink animation";
char TEXT_LEDSCOUNT[] = "LEDs Count";
char TEXT_CENTEROFFSET[] = "Center Offset";
char TEXT_SMALLOFFSET[] = "Small Offset";
char TEXT_BIGOFFSET[] = "Big Offset";
char TEXT_LEDSTRIP_MILLIAMP[] = "Ledstrip 0.1A";
char TEXT_BLINKBEEP[] = "Blink Beep";
char TEXT_FULLBLINK[] = "Full blink";
char TEXT_LEDSTRIP_STVO[] = "Enable StVO";
char TEXT_STVO_FRONTOFFSET[] = "StVO Front Offset";
char TEXT_STVO_FRONTLENGTH[] = "StVO Front Length";
char TEXT_STVO_ENABLEFRONTLIGHT[] = "StVO Front Enable";
char TEXT_ANIMATION_MULTIPLIER[] = "Animation Multiplier";
char TEXT_LEDSTRIP_BRIGHTNESS[] = "Ledstrip Brightness";
char TEXT_LEDSTRIP_ALLCUSTOMOFF[] = "All custom off";
char TEXT_LEDSTRIP_EN_BLINK_ANIM[] = "Animated Blink";
char TEXT_LEDSTRIP_CHANGE_OTA_ANIM[] = "Change Ota animation";
char TEXT_OTAANIM_NONE[] = "None";
char TEXT_OTAANIM_PROGRESS[] = "Progress Bar";
char TEXT_OTAANIM_COLOR[] = "Color change";
//char TEXT_BACK[] = "Back";
//LedstripSelectAnimationMenu
char TEXT_SELECTANIMATION[] = "Select Animation";
char TEXT_ANIMATION_DEFAULTRAINBOW[] = "Default Rainbow";
char TEXT_ANIMATION_BETTERRAINBOW[] = "Better Rainbow";
char TEXT_ANIMATION_SPEEDSYNCANIMATION[] = "Speed Sync";
char TEXT_ANIMATION_CUSTOMCOLOR[] = "Custom Color";
//LedstripSelectBlinkMenu
char TEXT_ANIMATION_BLINKNONE[] = "Blink Off";
char TEXT_ANIMATION_BLINKLEFT[] = "Blink Left";
char TEXT_ANIMATION_BLINKRIGHT[] = "Blink Right";
char TEXT_ANIMATION_BLINKBOTH[] = "Blink Both";
//LockscreenSettingsMenu
char TEXT_LOCKSCREENSETTINGS[] = "Lockscreen Settings";
char TEXT_ALLOWPRESETSWITCH[] = "Allow preset switch";
char TEXT_PINDIGIT0[] = "PIN digit0";
char TEXT_PINDIGIT1[] = "PIN digit1";
char TEXT_PINDIGIT2[] = "PIN digit2";
char TEXT_PINDIGIT3[] = "PIN digit3";
//char TEXT_BACK[] = "Back";
//ModesSettingsMenu
//char TEXT_MODESSETTINGS[] = "Modes settings";
char TEXT_DEFAULTMODESETTIGNS[] = "Default mode settings";
char TEXT_TEMPOMATMODESETTINGS[] = "Tempomat mode settings";
//char TEXT_LARSMMODESETTINGS[] = "Larsm mode settings";
//char TEXT_GAMETRAKMODESETTINGS[] = "Gametrak mode settings";
//char TEXT_BACK[] = "Back";
//MosfetsMenu
//char TEXT_MOSFETS[] = "Mosfets";
char TEXT_MOSFET0[] = "Mosfet0";
char TEXT_MOSFET1[] = "Mosfet1";
char TEXT_MOSFET2[] = "Mosfet2";
//TempomatModeSettingsMenu
//char TEXT_TEMPOMATMODESETTINGS[] = "Tempomat mode settings";
char TEXT_APPLY[] = "Apply";
char TEXT_NCRUISEMOTTGT[] = "nCruiseMotTgt";
//char TEXT_MODELMODE[] = "Model mode";
//char TEXT_BACK[] = "Back";
//WiFiSettingsMenu
//char TEXT_WIFISETTINGS[] = "WiFi settings";
//char TEXT_GENERICWIFISETTINGS[] = "Generic WiFi settings";
//char TEXT_BACK[] = "Back";
//BoardcomputerHardwareSettingsMenu
//char TEXT_BOARDCOMPUTERHARDWARESETTINGS[] = "Boardcomputer H/W settings";
//char TEXT_LOCKSCREENSETTINGS[] = "Lockscreen Settings";
char TEXT_CALIBRATE[] = "Calibrate";
char TEXT_SAMPLECOUNT[] = "sampleCount";
char TEXT_GASMIN[] = "gasMin";
char TEXT_GASMAX[] = "gasMax";
char TEXT_BREMSMIN[] = "bremsMin";
char TEXT_BREMSMAX[] = "bremsMax";
char TEXT_DPADDEBOUNCE[] = "dpadDebounce";
char TEXT_GAMETRAKCALIBRATE[] = "Gametrak calibrate";
char TEXT_SETGAMETRAKXMIN[] = "Set gametrakXMin";
char TEXT_SETGAMETRAKXMAX[] = "Set gametrakXMax";
char TEXT_SETGAMETRAKYMIN[] = "Set gametrakYMin";
char TEXT_SETGAMETRAKYMAX[] = "Set gametrakYMax";
char TEXT_SETGAMETRAKDISTMIN[] = "Set gametrakDistMin";
char TEXT_SETGAMETRAKDISTMAX[] = "Set gametrakDistMax";
char TEXT_TIMERS[] = "Timers";
//char TEXT_BACK[] = "Back";
//ProfilesMenu
//char TEXT_PROFILES[] = "Profiles";
char TEXT_PROFILE0[] = "Profile 0";
char TEXT_PROFILE1[] = "Profile 1";
char TEXT_PROFILE2[] = "Profile 2";
char TEXT_PROFILE3[] = "Profile 3";
//char TEXT_BACK[] = "Back";
//PresetsMenu
//char TEXT_PRESETS[] = "Presets";
char TEXT_DEFAULTEVERYTHING[] = "Default everything";
char TEXT_DEFAULTLIMITS[] = "Default limits";
char TEXT_KIDSLIMITS[] = "Kids limits";
char TEXT_DEFAULTPOTI[] = "Default poti";
char TEXT_DEFAULTCONTROLLERHARDWARE[] = "Default controller H/W";
char TEXT_MOSFETSOFFCONTROLLERHARDWARE[] = "MOSFETs off controller H/W";
char TEXT_SPINNERCONTROLLERHARDWARE[] = "Spinner controller H/W";
char TEXT_DEFAULTBOARDCOMPUTERHARDWARE[] = "Default boardcomputer H/W";
char TEXT_DEFAULTDEFAULTMODE[] = "Default defaultMode";
char TEXT_SINUSOIDALDEFAULTMODE[] = "Sinusoidal defaultMode";
char TEXT_DEFAULTTEMPOMATMODE[] = "Default tempomatMode";
char TEXT_DEFAULTLARSMMODE[] = "Default larsmMode";
char TEXT_STREET[] = "Street";
char TEXT_SIDEWALK[] = "Sidewalk";
char TEXT_POLICE[] = "Police";
char TEXT_RACE[] = "Race";
//SelectModeMenu
//char TEXT_SELECTMODE[] = "Select mode";
char TEXT_DEFAULT[] = "Default";
char TEXT_TEMPOMAT[] = "Tempomat";
char TEXT_LARSM[] = "Larsm";
char TEXT_REMOTECONTROL[] = "Remote control";
char TEXT_GAMETRAK[] = "Gametrak";
char TEXT_MOTORTEST[] = "Motortest";
//char TEXT_BACK[] = "Back";
//TimersMenu
//char TEXT_TIMERS[] = "Timers";
char TEXT_POTIREADRATE[] = "Poti read rate";
char TEXT_MODEUPDATERATE[] = "Mode update rate";
char TEXT_STATSUPDATERATE[] = "Stats update rate";
char TEXT_DISPLAYUPDATERATE[] = "Display update rate";
char TEXT_DISPLAYREDRAWRATE[] = "Display redraw rate";
#ifdef FEATURE_CAN
char TEXT_CANRECEIVERATE[] = "CAN receive rate";
#endif
//char TEXT_BACK[] = "Back";
//TimeSettingsMenu
//char TEXT_TIME[] = "Time";
char TEXT_OFFSET[] = "Offset";
char TEXT_DAYLIGHTSAVINGMODE[] = "Daylight Saving";
char TEXT_NTPENABLED[] = "NTP Enabled";
char TEXT_NTPSERVER[] = "NTP Server";
char TEXT_NTPMODE[] = "NTP Mode";
char TEXT_NTPINTERVAL[] = "NTP Interval";
//char TEXT_BACK[] = "Back";
//ChangeValueDisplay<BluetoothMode>
char TEXT_OFF[] = "Off";
char TEXT_MASTER[] = "Master";
char TEXT_SLAVE[] = "Slave";
//ChangeValueDisplay<ControlMode>
char TEXT_OPENMODE[] = "Open mode";
char TEXT_VOLTAGE[] = "Voltage";
char TEXT_SPEED[] = "Speed";
char TEXT_TORQUE[] = "Torque";
//char TEXT_BACK[] = "Back";
//ChangeValueDisplay<ControlType>
char TEXT_COMMUTATION[] = "Commutation";
char TEXT_SINUSOIDAL[] = "Sinusoidal";
char TEXT_FIELDORIENTEDCONTROL[] = "Field oriented control";
//char TEXT_BACK[] = "Back";
//ChangeValueDisplay<HandbremseMode>
char TEXT_HANDBREMS_MOSFETS_OFF[] = "Mosfets off";
char TEXT_HANDBREMS_OPENMODE[] = "Open Mode";
char TEXT_HANDBREMS_SPEED0[] = "Speed 0";
char TEXT_HANDBREMSE[] = "Handbremse";
//ChangeValueDisplay<LarsmMode::Mode>
char TEXT_LARSMMODE1[] = "Mode1";
char TEXT_LARSMMODE2[] = "Mode2";
char TEXT_LARSMMODE3[] = "Mode3";
char TEXT_LARSMMODE4[] = "Mode4";
//char TEXT_BACK[] = "Back";
//ChangeValueDisplay<UnifiedModelMode>
//char TEXT_COMMUTATION[] = "Commutation";
//char TEXT_SINUSOIDAL[] = "Sinusoidal";
char TEXT_FOCVOLTAGE[] = "FOC/Voltage";
char TEXT_FOCSPEED[] = "FOC/Speed";
char TEXT_FOCTORQUE[] = "FOC/Torque";
//char TEXT_BACK[] = "Back";
//ChangeValueDisplay<wifi_mode_t>
char TEXT_WIFI_MODE_NULL[] = "WIFI_MODE_NULL";
char TEXT_WIFI_MODE_STA[] = "WIFI_MODE_STA";
char TEXT_WIFI_MODE_AP[] = "WIFI_MODE_AP";
char TEXT_WIFI_MODE_APSTA[] = "WIFI_MODE_APSTA";
//char TEXT_BACK[] = "Back";
//ChangeValueDisplay<wifi_power_t>
char TEXT_WIFI_POWER_19_5dBm[] = "19.5dBm";
char TEXT_WIFI_POWER_19dBm[] = "19dBm";
char TEXT_WIFI_POWER_18_5dBm[] = "18.5dBm";
char TEXT_WIFI_POWER_17dBm[] = "17dBm";
char TEXT_WIFI_POWER_15dBm[] = "15dBm";
char TEXT_WIFI_POWER_13dBm[] = "13dBm";
char TEXT_WIFI_POWER_11dBm[] = "11dBm";
char TEXT_WIFI_POWER_8_5dBm[] = "8.5dBm";
char TEXT_WIFI_POWER_7dBm[] = "7dBm";
char TEXT_WIFI_POWER_5dBm[] = "5dBm";
char TEXT_WIFI_POWER_2dBm[] = "2dBm";
char TEXT_WIFI_POWER_MINUS_1dBm[] = "-1dBm";
//char TEXT_BACK[] = "Back";
//Crashmenu
char TEXT_CRASHMENU[] = "Crash Menu";
char TEXT_CRASH_ASSERT[] = "assert(0)";
char TEXT_CRASH_DIVZERO[] = "42 / 0";
//SelectBuildServerMenu
char TEXT_SELECTBUILDSERVERMENU[] = "Select Buildserver";
char TEXT_NOBUILDSERVERCONFIGURED[] = "Not configured";
//Otamenu
char TEXT_UPDATENOW[] = "Update now";
char TEXT_SELECTBUILD[] = "Select build";
char TEXT_OTA_NOBUILDSERVERAVAILABLE[] = "E:No server saved.";
char TEXT_OTA_NOBUILDSERVERSELECTED[] = "E:No server selected.";
char TEXT_OTA_NOCONNECTION[] = "E:No internet.";
char TEXT_OTA_WAITFORRESPONSE[] = "Wait for response...";
//LedstripColorMenu
char TEXT_LEDSTRIPCOLORMENU[] = "Customize Ledstrip";
//StatisticsMenu
char TEXT_STATISTICSMENU[] = "Statistics";
char TEXT_STATSSAVE[] = "Save kilometers";
char TEXT_STATSCLEAR[] = "Clear current km";
#ifdef FEATURE_CAN
char TEXT_POWERSUPPLY[] = "Powersupply";
#endif
char TEXT_REENABLE_MENUITEMS[] = "Show advanced";
} // namespace

812
main/texts.h
View File

@ -1,14 +1,13 @@
#pragma once
namespace bobbytexts {
//AboutMenu
constexpr char TEXT_ABOUT[] = "About";
constexpr char TEXT_BACK[] = "Back";
extern char TEXT_ABOUT[];
extern char TEXT_BACK[];
//AccessPointWifiSettingsMenu
constexpr char TEXT_ACCESSPOINTWIFISETTINGS[] = "Access Point WiFi settings";
constexpr char TEXT_WIFIAPENABLED[] = "AP enabled";
constexpr char TEXT_RESEND_DNS[] = "Resend DNS";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_ACCESSPOINTWIFISETTINGS[];
extern char TEXT_WIFIAPENABLED[];
extern char TEXT_RESEND_DNS[];
//extern char TEXT_BACK[];
#ifdef TEXTS_PLUGIN
#include TEXTS_PLUGIN
@ -16,507 +15,522 @@ constexpr char TEXT_RESEND_DNS[] = "Resend DNS";
#ifdef FEATURE_BLUETOOTH
//BluetoothSettingsMenu
constexpr char TEXT_BLUETOOTHSETTINGS[] = "Bluetooth settings";
constexpr char TEXT_BLUETOOTHBEGIN[] = "begin()";
constexpr char TEXT_BLUETOOTHBEGINMASTER[] = "begin() Master";
constexpr char TEXT_BLUETOOTHFLUSH[] = "flush()";
constexpr char TEXT_BLUETOOTHEND[] = "end()";
constexpr char TEXT_BLUETOOTHDISCONNECT[] = "disconnect()";
constexpr char TEXT_AUTOBLUETOOTHMODE[] = "Auto bluetooth mode";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_BLUETOOTHSETTINGS[];
extern char TEXT_BLUETOOTHBEGIN[];
extern char TEXT_BLUETOOTHBEGINMASTER[];
extern char TEXT_BLUETOOTHFLUSH[];
extern char TEXT_BLUETOOTHEND[];
extern char TEXT_BLUETOOTHDISCONNECT[];
extern char TEXT_AUTOBLUETOOTHMODE[];
//extern char TEXT_BACK[];
//BmsMenu
#ifdef FEATURE_BMS
constexpr char TEXT_BMS[] = "BMS";
constexpr char TEXT_CONNECTBMS[] = "Connect BMS";
constexpr char TEXT_DISCONNECTBMS[] = "Disonnect BMS";
constexpr char TEXT_TURNONCHARGE[] = "Turn on charge";
constexpr char TEXT_TURNOFFCHARGE[] = "Turn off charge";
constexpr char TEXT_TURNONDISCHARGE[] = "Turn on discharge";
constexpr char TEXT_TURNOFFDISCHARGE[] = "Turn off discharge";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_BMS[];
extern char TEXT_CONNECTBMS[];
extern char TEXT_DISCONNECTBMS[];
extern char TEXT_TURNONCHARGE[];
extern char TEXT_TURNOFFCHARGE[];
extern char TEXT_TURNONDISCHARGE[];
extern char TEXT_TURNOFFDISCHARGE[];
//extern char TEXT_BACK[];
#endif
#endif
#ifdef FEATURE_BLE
//BleSettingsMenu
constexpr char TEXT_BLESETTINGS[] = "BLE settings";
constexpr char TEXT_BLEENABLED[] = "BLE enabled";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_BLESETTINGS[];
extern char TEXT_BLEENABLED[];
//extern char TEXT_BACK[];
#endif
#ifdef FEATURE_CLOUD
//CloudSettingsMenu
constexpr char TEXT_CLOUDSETTINGS[] = "Cloud settings";
constexpr char TEXT_CLOUDENABLED[] = "Tcp Cloud enabled";
constexpr char TEXT_UDPCLOUDENABLED[] = "Udp 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_UDPSENDRATE[] = "Udp send rate";
constexpr char TEXT_UDPUSESTRING[] = "Udp use std::string";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_CLOUDSETTINGS[];
extern char TEXT_CLOUDENABLED[];
extern char TEXT_UDPCLOUDENABLED[];
extern char TEXT_CLOUDTRANSMITTIMEOUT[];
extern char TEXT_CLOUDCOLLECTRATE[];
extern char TEXT_CLOUDSENDRATE[];
extern char TEXT_UDPSENDRATE[];
extern char TEXT_UDPUSESTRING[];
//extern char TEXT_BACK[];
#endif
//DebugMenu
constexpr char TEXT_LOADSETTINGS[] = "Load settings";
constexpr char TEXT_SAVESETTINGS[] = "Save settings";
constexpr char TEXT_ERASENVS[] = "Erase NVS";
constexpr char TEXT_FRONTCOMMAND[] = "Front command";
constexpr char TEXT_BACKCOMMAND[] = "Back command";
constexpr char TEXT_FRONTLEFTCOMMAND[] = "Front left command";
constexpr char TEXT_FRONTRIGHTCOMMAND[] = "Front right command";
constexpr char TEXT_BACKLEFTCOMMAND[] = "Back left command";
constexpr char TEXT_BACKRIGHTCOMMAND[] = "Back right command";
constexpr char TEXT_FRONTFEEDBACK[] = "Front feedback";
constexpr char TEXT_BACKFEEDBACK[] = "Back feedback";
constexpr char TEXT_FRONTLEFTFEEDBACK[] = "Front left feedback";
constexpr char TEXT_FRONTRIGHTFEEDBACK[] = "Front right feedback";
constexpr char TEXT_BACKLEFTFEEDBACK[] = "Back left feedback";
constexpr char TEXT_BACKRIGHTFEEDBACK[] = "Back right feedback";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_LOADSETTINGS[];
extern char TEXT_SAVESETTINGS[];
extern char TEXT_ERASENVS[];
extern char TEXT_FRONTCOMMAND[];
extern char TEXT_BACKCOMMAND[];
extern char TEXT_FRONTLEFTCOMMAND[];
extern char TEXT_FRONTRIGHTCOMMAND[];
extern char TEXT_BACKLEFTCOMMAND[];
extern char TEXT_BACKRIGHTCOMMAND[];
extern char TEXT_FRONTFEEDBACK[];
extern char TEXT_BACKFEEDBACK[];
extern char TEXT_FRONTLEFTFEEDBACK[];
extern char TEXT_FRONTRIGHTFEEDBACK[];
extern char TEXT_BACKLEFTFEEDBACK[];
extern char TEXT_BACKRIGHTFEEDBACK[];
//extern char TEXT_BACK[];
//MainMenu
constexpr char TEXT_MAINMENU[] = "Main menu";
constexpr char TEXT_STATUS[] = "Status";
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_BMS[] = "BMS";
constexpr char TEXT_SETTINGS[] = "Settings";
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";
extern char TEXT_MAINMENU[];
extern char TEXT_STATUS[];
extern char TEXT_SELECTMODE[];
extern char TEXT_MODESETTINGS[];
extern char TEXT_PRESETS[];
extern char TEXT_PROFILES[];
extern char TEXT_GRAPHS[];
//extern char TEXT_BMS[];
extern char TEXT_SETTINGS[];
extern char TEXT_LOCKVEHICLE[];
extern char TEXT_MOSFETS[];
extern char TEXT_DEMOS[];
extern char TEXT_GARAGE[];
extern char TEXT_UPDATE[];
extern char TEXT_POWEROFF[];
extern char TEXT_REBOOT[];
extern char TEXT_DEBUG[];
extern char TEXT_BATTERY[];
extern char TEXT_BATTERYDEBUG[];
extern char TEXT_TOGGLECLOUDDEBUG[];
//BatteryMenu
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";
extern char TEXT_CELL_SERIES[];
extern char TEXT_CELL_PARALLEL[];
extern char TEXT_SELECT_CELL_TYPE[];
extern char TEXT_CELL_TYPE[];
extern char TEXT_BATTERY_CALIBRATE[];
extern char TEXT_BATTERY_TYPE_22P[];
extern char TEXT_BATTERY_TYPE_HG2[];
extern char TEXT_BATTERY_TYPE_MH1[];
extern char TEXT_BATTERY_TYPE_VTC5[];
extern char TEXT_BATTERY_TYPE_BAK_25R[];
extern char TEXT_BATTERY_WHKM[];
extern char TEXT_BATTERY_APPLYCALIB[];
extern char TEXT_VOLTAGECALIBRATION_RESET[];
//CalibrateVoltageDisplay
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";
extern char TEXT_VOLTAGECALIBRATION_30V[];
extern char TEXT_VOLTAGECALIBRATION_50V[];
extern char TEXT_VOLTAGECALIBRATION_VALUE_30_FRONT[];
extern char TEXT_VOLTAGECALIBRATION_VALUE_30_BACK[];
extern char TEXT_VOLTAGECALIBRATION_VALUE_50_FRONT[];
extern char TEXT_VOLTAGECALIBRATION_VALUE_50_BACK[];
//SettingsMenu
//constexpr char TEXT_SETTINGS[] = "Settings";
constexpr char TEXT_BACKLIGHT[] = "Backlight";
constexpr char TEXT_LIMITSSETTINGS[] = "Limits settings";
constexpr char TEXT_WIFISETTINGS[] = "WiFi settings";
//constexpr char TEXT_BLUETOOTHSETTINGS[] = "Bluetooth settings";
//constexpr char TEXT_BLESETTINGS[] = "BLE settings";
//constexpr char TEXT_CLOUDSETTINGS[] = "Cloud settings";
constexpr char TEXT_TIME[] = "Time";
constexpr char TEXT_MODESSETTINGS[] = "Modes settings";
constexpr char TEXT_CONTROLLERHARDWARESETTINGS[] = "Controller H/W settings";
constexpr char TEXT_BOARDCOMPUTERHARDWARESETTINGS[] = "Boardcomputer H/W settings";
constexpr char TEXT_AUTOCONNECTBMS[] = "Auto connect BMS";
constexpr char TEXT_BUZZER[] = "Buzzer";
constexpr char TEXT_FRONTLED[] = "Front LED";
constexpr char TEXT_BACKLED[] = "Back LED";
//constexpr char TEXT_ABOUT[] = "About";
//constexpr char TEXT_BACK[] = "Back";
//extern char TEXT_SETTINGS[];
extern char TEXT_BACKLIGHT[];
extern char TEXT_LIMITSSETTINGS[];
extern char TEXT_WIFISETTINGS[];
//extern char TEXT_BLUETOOTHSETTINGS[];
//extern char TEXT_BLESETTINGS[];
//extern char TEXT_CLOUDSETTINGS[];
extern char TEXT_TIME[];
extern char TEXT_MODESSETTINGS[];
extern char TEXT_CONTROLLERHARDWARESETTINGS[];
extern char TEXT_BOARDCOMPUTERHARDWARESETTINGS[];
extern char TEXT_AUTOCONNECTBMS[];
extern char TEXT_BUZZER[];
extern char TEXT_FRONTLED[];
extern char TEXT_BACKLED[];
//extern char TEXT_ABOUT[];
//extern char TEXT_BACK[];
//ControllerHardwareSettings
//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";
//extern char TEXT_CONTROLLERHARDWARESETTINGS[];
extern char TEXT_WHEELDIAMETERMM[];
extern char TEXT_WHEELDIAMETERINCH[];
extern char TEXT_NUMMAGNETPOLES[];
extern char TEXT_SETENABLED[];
extern char TEXT_SETINVERTED[];
extern char TEXT_SWAPFRONTBACK[];
#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";
extern char TEXT_FRONTSENDCAN[];
extern char TEXT_BACKSENDCAN[];
extern char TEXT_CANTRANSMITTIMEOUT[];
extern char TEXT_CANRECEIVETIMEOUT[];
#endif
//constexpr char TEXT_BACK[] = "Back";
//extern char TEXT_BACK[];
//StationWifiSettingsMenu
constexpr char TEXT_STATIONWIFISETTINGS[] = "Station WiFi settings";
constexpr char TEXT_WIFISTAENABLED[] = "STA enabled";
constexpr char TEXT_WIFITRIGGERSCAN[] = "Trigger Scan";
constexpr char TEXT_WIFISCANRESULTS[] = "WiFi scan results";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_STATIONWIFISETTINGS[];
extern char TEXT_WIFISTAENABLED[];
extern char TEXT_WIFITRIGGERSCAN[];
extern char TEXT_WIFISCANRESULTS[];
//extern char TEXT_BACK[];
//DemosMenu
//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";
//extern char TEXT_DEMOS[];
extern char TEXT_STARFIELD[];
extern char TEXT_PINGPONG[];
extern char TEXT_SPIRO[];
extern char TEXT_GAMEOFLIFE[];
//extern char TEXT_BACK[];
//BuzzerMenu
//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";
//extern char TEXT_BUZZER[];
extern char TEXT_FRONTFREQ[];
extern char TEXT_FRONTPATTERN[];
extern char TEXT_BACKFREQ[];
extern char TEXT_BACKPATTERN[];
extern char TEXT_REVERSEBEEP[];
extern char TEXT_REVERSEBEEPFREQ0[];
extern char TEXT_REVERSEBEEPFREQ1[];
extern char TEXT_REVERSEBEEPDURATION0[];
extern char TEXT_REVERSEBEEPDURATION1[];
//extern char TEXT_BACK[];
//LimitsSettingsMenu
//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";
//extern char TEXT_LIMITSSETTINGS[];
extern char TEXT_IMOTMAX[];
extern char TEXT_IDCMAX[];
extern char TEXT_NMOTMAXKMH[];
extern char TEXT_NMOTMAX[];
extern char TEXT_FIELDWEAKMAX[];
extern char TEXT_PHASEADVMAX[];
//extern char TEXT_BACK[];
//DebugMenu
//constexpr char TEXT_DEBUG[] = "Debug";
constexpr char TEXT_DYNAMICMENU[] = "Dynamic menu";
//constexpr char TEXT_BACK[] = "Back";
//extern char TEXT_DEBUG[];
extern char TEXT_DYNAMICMENU[];
//extern char TEXT_BACK[];
//DefaultModeSettingsMenu
//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_BACK[] = "Back";
//extern char TEXT_DEFAULTMODESETTINGS[];
extern char TEXT_MODELMODE[];
extern char TEXT_HYBRIDMODE[];
extern char TEXT_SQUAREGAS[];
extern char TEXT_SQUAREBREMS[];
extern char TEXT_ENABLESMOOTHINGUP[];
extern char TEXT_ENABLESMOOTHINGDOWN[];
extern char TEXT_ENABLEFWSMOOTHINGUP[];
extern char TEXT_ENABLEFWSMOOTHINGDOWN[];
extern char TEXT_FWSMOOTHING_LIMIT[];
extern char TEXT_SMOOTHINGVAL[];
extern char TEXT_FRONTPERCENTAGE[];
extern char TEXT_BACKPERCENTAGE[];
extern char TEXT_ADDSCHWELLE[];
extern char TEXT_SUBGASVAL[];
extern char TEXT_SUBBRAKEVAL[];
extern char TEXT_ADDGASVAL[];
extern char TEXT_ADDBRAKEVAL[];
extern char TEXT_HYBRIDENABLE[];
extern char TEXT_HYBRIDACTIVATIONLIMIT[];
extern char TEXT_HYBRIDDEACTIVATIONLIMIT[];
extern char TEXT_LIMITS_TO_NEAR[];
extern char TEXT_HANDBREMSE_ENABLE[];
extern char TEXT_HANDBREMSE_AUTOMATIC[];
extern char TEXT_HANDBREMSE_MODE[];
extern char TEXT_HANDBREMSE_TRIGGERTIMEOUT[];
extern char TEXT_HANDBREMSE[];
//extern char TEXT_BACK[];
//DynamicDebugMenu
//constexpr char TEXT_DYNAMICMENU[] = "Dynamic menu";
//constexpr char TEXT_BACK[] = "Back";
//extern char TEXT_DYNAMICMENU[];
//extern char TEXT_BACK[];
//EnableMenu
//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";
//extern char TEXT_SETENABLED[];
extern char TEXT_ENABLEFRONTLEFT[];
extern char TEXT_ENABLEFRONTRIGHT[];
extern char TEXT_ENABLEBACKLEFT[];
extern char TEXT_ENABLEBACKRIGHT[];
//extern char TEXT_BACK[];
//GametrakModeSettingsMenu
constexpr char TEXT_GAMETRAKMODESETTINGS[] = "Gametrak mode settings";
extern char TEXT_GAMETRAKMODESETTINGS[];
//GenericWifiSettingsMenu
constexpr char TEXT_GENERICWIFISETTINGS[] = "Generic WiFi settings";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_GENERICWIFISETTINGS[];
//extern char TEXT_BACK[];
//GraphsMenu
//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";
//extern char TEXT_GRAPHS[];
extern char TEXT_GAS[];
extern char TEXT_BREMS[];
extern char TEXT_POTIS[];
extern char TEXT_AVGSPEED[];
extern char TEXT_AVGSPEEDKMH[];
extern char TEXT_SUMCURRENT[];
extern char TEXT_FRONTVOLTAGE[];
extern char TEXT_BACKVOLTAGE[];
extern char TEXT_VOLTAGES[];
extern char TEXT_BMSVOLTAGE[];
extern char TEXT_BMSCURRENT[];
extern char TEXT_BMSPOWER[];
extern char TEXT_SUMCURRENTSCOMPARISON[];
extern char TEXT_MOTORCURRENTS[];
extern char TEXT_RSSI[];
//extern char TEXT_BACK[];
//InvertMenu
//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";
//extern char TEXT_SETINVERTED[];
extern char TEXT_INVERTFRONTLEFT[];
extern char TEXT_INVERTFRONTRIGHT[];
extern char TEXT_INVERTBACKLEFT[];
extern char TEXT_INVERTBACKRIGHT[];
//extern char TEXT_BACK[];
//LarsmModeSettingsMenu
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";
extern char TEXT_LARSMMODESETTINGS[];
//extern char TEXT_MODELMODE[];
extern char TEXT_SETMODE[];
extern char TEXT_SETITERATIONS[];
//extern char TEXT_BACK[];
//MotortestModeSettingsMenu
constexpr char TEXT_MOTORTESTMODESETTINGS[] = "Motortest mode seetings";
constexpr char TEXT_MOTORTESTMAXPWM[] = "Max Pwm";
constexpr char TEXT_MOTORTESTMULTIPLIKATOR[] = "Acceleration";
extern char TEXT_MOTORTESTMODESETTINGS[];
extern char TEXT_MOTORTESTMAXPWM[];
extern char TEXT_MOTORTESTMULTIPLIKATOR[];
//LedstripMenu
constexpr char TEXT_LEDSTRIP[] = "Ledstrip";
constexpr char TEXT_LEDANIMATION[] = "LED Animation";
constexpr char TEXT_BRAKELIGHTS[] = "Brake Lights";
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_LEDSTRIP_MILLIAMP[] = "Ledstrip 0.1A";
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_EN_BLINK_ANIM[] = "Animated Blink";
constexpr char TEXT_LEDSTRIP_CHANGE_OTA_ANIM[] = "Change Ota animation";
extern char TEXT_LEDSTRIP[];
extern char TEXT_LEDANIMATION[];
extern char TEXT_BRAKELIGHTS[];
extern char TEXT_BLINKANIMATION[];
extern char TEXT_ANIMATION_TYPE[];
extern char TEXT_LEDSCOUNT[];
extern char TEXT_CENTEROFFSET[];
extern char TEXT_SMALLOFFSET[];
extern char TEXT_BIGOFFSET[];
extern char TEXT_LEDSTRIP_MILLIAMP[];
extern char TEXT_BLINKBEEP[];
extern char TEXT_FULLBLINK[];
extern char TEXT_LEDSTRIP_STVO[];
extern char TEXT_STVO_FRONTOFFSET[];
extern char TEXT_STVO_FRONTLENGTH[];
extern char TEXT_STVO_ENABLEFRONTLIGHT[];
extern char TEXT_ANIMATION_MULTIPLIER[];
extern char TEXT_LEDSTRIP_BRIGHTNESS[];
extern char TEXT_LEDSTRIP_ALLCUSTOMOFF[];
extern char TEXT_LEDSTRIP_EN_BLINK_ANIM[];
extern char TEXT_LEDSTRIP_CHANGE_OTA_ANIM[];
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";
extern char TEXT_OTAANIM_NONE[];
extern char TEXT_OTAANIM_PROGRESS[];
extern char TEXT_OTAANIM_COLOR[];
//extern char TEXT_BACK[];
//LedstripSelectAnimationMenu
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";
extern char TEXT_SELECTANIMATION[];
extern char TEXT_ANIMATION_DEFAULTRAINBOW[];
extern char TEXT_ANIMATION_BETTERRAINBOW[];
extern char TEXT_ANIMATION_SPEEDSYNCANIMATION[];
extern char TEXT_ANIMATION_CUSTOMCOLOR[];
//LedstripSelectBlinkMenu
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";
extern char TEXT_ANIMATION_BLINKNONE[];
extern char TEXT_ANIMATION_BLINKLEFT[];
extern char TEXT_ANIMATION_BLINKRIGHT[];
extern char TEXT_ANIMATION_BLINKBOTH[];
//LockscreenSettingsMenu
constexpr char TEXT_LOCKSCREENSETTINGS[] = "Lockscreen Settings";
constexpr char TEXT_ALLOWPRESETSWITCH[] = "Allow preset switch";
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";
extern char TEXT_LOCKSCREENSETTINGS[];
extern char TEXT_ALLOWPRESETSWITCH[];
extern char TEXT_PINDIGIT0[];
extern char TEXT_PINDIGIT1[];
extern char TEXT_PINDIGIT2[];
extern char TEXT_PINDIGIT3[];
//extern char TEXT_BACK[];
//ModesSettingsMenu
//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";
//extern char TEXT_MODESSETTINGS[];
extern char TEXT_DEFAULTMODESETTIGNS[];
extern char TEXT_TEMPOMATMODESETTINGS[];
//extern char TEXT_LARSMMODESETTINGS[];
//extern char TEXT_GAMETRAKMODESETTINGS[];
//extern char TEXT_BACK[];
//MosfetsMenu
//constexpr char TEXT_MOSFETS[] = "Mosfets";
constexpr char TEXT_MOSFET0[] = "Mosfet0";
constexpr char TEXT_MOSFET1[] = "Mosfet1";
constexpr char TEXT_MOSFET2[] = "Mosfet2";
//extern char TEXT_MOSFETS[];
extern char TEXT_MOSFET0[];
extern char TEXT_MOSFET1[];
extern char TEXT_MOSFET2[];
//TempomatModeSettingsMenu
//constexpr char TEXT_TEMPOMATMODESETTINGS[] = "Tempomat mode settings";
constexpr char TEXT_APPLY[] = "Apply";
constexpr char TEXT_NCRUISEMOTTGT[] = "nCruiseMotTgt";
//constexpr char TEXT_MODELMODE[] = "Model mode";
//constexpr char TEXT_BACK[] = "Back";
//extern char TEXT_TEMPOMATMODESETTINGS[];
extern char TEXT_APPLY[];
extern char TEXT_NCRUISEMOTTGT[];
//extern char TEXT_MODELMODE[];
//extern char TEXT_BACK[];
//WiFiSettingsMenu
//constexpr char TEXT_WIFISETTINGS[] = "WiFi settings";
//constexpr char TEXT_GENERICWIFISETTINGS[] = "Generic WiFi settings";
//constexpr char TEXT_BACK[] = "Back";
//extern char TEXT_WIFISETTINGS[];
//extern char TEXT_GENERICWIFISETTINGS[];
//extern char TEXT_BACK[];
//BoardcomputerHardwareSettingsMenu
//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";
//extern char TEXT_BOARDCOMPUTERHARDWARESETTINGS[];
//extern char TEXT_LOCKSCREENSETTINGS[];
extern char TEXT_CALIBRATE[];
extern char TEXT_SAMPLECOUNT[];
extern char TEXT_GASMIN[];
extern char TEXT_GASMAX[];
extern char TEXT_BREMSMIN[];
extern char TEXT_BREMSMAX[];
extern char TEXT_DPADDEBOUNCE[];
extern char TEXT_GAMETRAKCALIBRATE[];
extern char TEXT_SETGAMETRAKXMIN[];
extern char TEXT_SETGAMETRAKXMAX[];
extern char TEXT_SETGAMETRAKYMIN[];
extern char TEXT_SETGAMETRAKYMAX[];
extern char TEXT_SETGAMETRAKDISTMIN[];
extern char TEXT_SETGAMETRAKDISTMAX[];
extern char TEXT_TIMERS[];
//extern char TEXT_BACK[];
//ProfilesMenu
//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";
//extern char TEXT_PROFILES[];
extern char TEXT_PROFILE0[];
extern char TEXT_PROFILE1[];
extern char TEXT_PROFILE2[];
extern char TEXT_PROFILE3[];
//extern char TEXT_BACK[];
//PresetsMenu
//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";
//extern char TEXT_PRESETS[];
extern char TEXT_DEFAULTEVERYTHING[];
extern char TEXT_DEFAULTLIMITS[];
extern char TEXT_KIDSLIMITS[];
extern char TEXT_DEFAULTPOTI[];
extern char TEXT_DEFAULTCONTROLLERHARDWARE[];
extern char TEXT_MOSFETSOFFCONTROLLERHARDWARE[];
extern char TEXT_SPINNERCONTROLLERHARDWARE[];
extern char TEXT_DEFAULTBOARDCOMPUTERHARDWARE[];
extern char TEXT_DEFAULTDEFAULTMODE[];
extern char TEXT_SINUSOIDALDEFAULTMODE[];
extern char TEXT_DEFAULTTEMPOMATMODE[];
extern char TEXT_DEFAULTLARSMMODE[];
extern char TEXT_STREET[];
extern char TEXT_SIDEWALK[];
extern char TEXT_POLICE[];
extern char TEXT_RACE[];
//SelectModeMenu
//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";
//extern char TEXT_SELECTMODE[];
extern char TEXT_DEFAULT[];
extern char TEXT_TEMPOMAT[];
extern char TEXT_LARSM[];
extern char TEXT_REMOTECONTROL[];
extern char TEXT_GAMETRAK[];
extern char TEXT_MOTORTEST[];
//extern char TEXT_BACK[];
//TimersMenu
//constexpr char TEXT_TIMERS[] = "Timers";
constexpr char TEXT_POTIREADRATE[] = "Poti read rate";
constexpr char TEXT_MODEUPDATERATE[] = "Mode update rate";
constexpr char TEXT_STATSUPDATERATE[] = "Stats update rate";
constexpr char TEXT_DISPLAYUPDATERATE[] = "Display update rate";
constexpr char TEXT_DISPLAYREDRAWRATE[] = "Display redraw rate";
//extern char TEXT_TIMERS[];
extern char TEXT_POTIREADRATE[];
extern char TEXT_MODEUPDATERATE[];
extern char TEXT_STATSUPDATERATE[];
extern char TEXT_DISPLAYUPDATERATE[];
extern char TEXT_DISPLAYREDRAWRATE[];
#ifdef FEATURE_CAN
constexpr char TEXT_CANRECEIVERATE[] = "CAN receive rate";
extern char TEXT_CANRECEIVERATE[];
#endif
//constexpr char TEXT_BACK[] = "Back";
//extern char TEXT_BACK[];
//TimeSettingsMenu
//constexpr char TEXT_TIME[] = "Time";
constexpr char TEXT_OFFSET[] = "Offset";
constexpr char TEXT_DAYLIGHTSAVINGMODE[] = "Daylight Saving";
constexpr char TEXT_NTPENABLED[] = "NTP Enabled";
constexpr char TEXT_NTPSERVER[] = "NTP Server";
constexpr char TEXT_NTPMODE[] = "NTP Mode";
constexpr char TEXT_NTPINTERVAL[] = "NTP Interval";
//constexpr char TEXT_BACK[] = "Back";
//extern char TEXT_TIME[];
extern char TEXT_OFFSET[];
extern char TEXT_DAYLIGHTSAVINGMODE[];
extern char TEXT_NTPENABLED[];
extern char TEXT_NTPSERVER[];
extern char TEXT_NTPMODE[];
extern char TEXT_NTPINTERVAL[];
//extern char TEXT_BACK[];
//ChangeValueDisplay<BluetoothMode>
constexpr char TEXT_OFF[] = "Off";
constexpr char TEXT_MASTER[] = "Master";
constexpr char TEXT_SLAVE[] = "Slave";
extern char TEXT_OFF[];
extern char TEXT_MASTER[];
extern char TEXT_SLAVE[];
//ChangeValueDisplay<ControlMode>
constexpr char TEXT_OPENMODE[] = "Open mode";
constexpr char TEXT_VOLTAGE[] = "Voltage";
constexpr char TEXT_SPEED[] = "Speed";
constexpr char TEXT_TORQUE[] = "Torque";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_OPENMODE[];
extern char TEXT_VOLTAGE[];
extern char TEXT_SPEED[];
extern char TEXT_TORQUE[];
//extern char TEXT_BACK[];
//ChangeValueDisplay<ControlType>
constexpr char TEXT_COMMUTATION[] = "Commutation";
constexpr char TEXT_SINUSOIDAL[] = "Sinusoidal";
constexpr char TEXT_FIELDORIENTEDCONTROL[] = "Field oriented control";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_COMMUTATION[];
extern char TEXT_SINUSOIDAL[];
extern char TEXT_FIELDORIENTEDCONTROL[];
//extern char TEXT_BACK[];
//ChangeValueDisplay<HandbremseMode>
extern char TEXT_HANDBREMS_MOSFETS_OFF[];
extern char TEXT_HANDBREMS_OPENMODE[];
extern char TEXT_HANDBREMS_SPEED0[];
//ChangeValueDisplay<LarsmMode::Mode>
constexpr char TEXT_LARSMMODE1[] = "Mode1";
constexpr char TEXT_LARSMMODE2[] = "Mode2";
constexpr char TEXT_LARSMMODE3[] = "Mode3";
constexpr char TEXT_LARSMMODE4[] = "Mode4";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_LARSMMODE1[];
extern char TEXT_LARSMMODE2[];
extern char TEXT_LARSMMODE3[];
extern char TEXT_LARSMMODE4[];
//extern char TEXT_BACK[];
//ChangeValueDisplay<UnifiedModelMode>
//constexpr char TEXT_COMMUTATION[] = "Commutation";
//constexpr char TEXT_SINUSOIDAL[] = "Sinusoidal";
constexpr char TEXT_FOCVOLTAGE[] = "FOC/Voltage";
constexpr char TEXT_FOCSPEED[] = "FOC/Speed";
constexpr char TEXT_FOCTORQUE[] = "FOC/Torque";
//constexpr char TEXT_BACK[] = "Back";
//extern char TEXT_COMMUTATION[];
//extern char TEXT_SINUSOIDAL[];
extern char TEXT_FOCVOLTAGE[];
extern char TEXT_FOCSPEED[];
extern char TEXT_FOCTORQUE[];
//extern char TEXT_BACK[];
//ChangeValueDisplay<wifi_mode_t>
constexpr char TEXT_WIFI_MODE_NULL[] = "WIFI_MODE_NULL";
constexpr char TEXT_WIFI_MODE_STA[] = "WIFI_MODE_STA";
constexpr char TEXT_WIFI_MODE_AP[] = "WIFI_MODE_AP";
constexpr char TEXT_WIFI_MODE_APSTA[] = "WIFI_MODE_APSTA";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_WIFI_MODE_NULL[];
extern char TEXT_WIFI_MODE_STA[];
extern char TEXT_WIFI_MODE_AP[];
extern char TEXT_WIFI_MODE_APSTA[];
//extern char TEXT_BACK[];
//ChangeValueDisplay<wifi_power_t>
constexpr char TEXT_WIFI_POWER_19_5dBm[] = "19.5dBm";
constexpr char TEXT_WIFI_POWER_19dBm[] = "19dBm";
constexpr char TEXT_WIFI_POWER_18_5dBm[] = "18.5dBm";
constexpr char TEXT_WIFI_POWER_17dBm[] = "17dBm";
constexpr char TEXT_WIFI_POWER_15dBm[] = "15dBm";
constexpr char TEXT_WIFI_POWER_13dBm[] = "13dBm";
constexpr char TEXT_WIFI_POWER_11dBm[] = "11dBm";
constexpr char TEXT_WIFI_POWER_8_5dBm[] = "8.5dBm";
constexpr char TEXT_WIFI_POWER_7dBm[] = "7dBm";
constexpr char TEXT_WIFI_POWER_5dBm[] = "5dBm";
constexpr char TEXT_WIFI_POWER_2dBm[] = "2dBm";
constexpr char TEXT_WIFI_POWER_MINUS_1dBm[] = "-1dBm";
//constexpr char TEXT_BACK[] = "Back";
extern char TEXT_WIFI_POWER_19_5dBm[];
extern char TEXT_WIFI_POWER_19dBm[];
extern char TEXT_WIFI_POWER_18_5dBm[];
extern char TEXT_WIFI_POWER_17dBm[];
extern char TEXT_WIFI_POWER_15dBm[];
extern char TEXT_WIFI_POWER_13dBm[];
extern char TEXT_WIFI_POWER_11dBm[];
extern char TEXT_WIFI_POWER_8_5dBm[];
extern char TEXT_WIFI_POWER_7dBm[];
extern char TEXT_WIFI_POWER_5dBm[];
extern char TEXT_WIFI_POWER_2dBm[];
extern char TEXT_WIFI_POWER_MINUS_1dBm[];
//extern char TEXT_BACK[];
//Crashmenu
constexpr char TEXT_CRASHMENU[] = "Crash Menu";
constexpr char TEXT_CRASH_ASSERT[] = "assert(0)";
constexpr char TEXT_CRASH_DIVZERO[] = "42 / 0";
extern char TEXT_CRASHMENU[];
extern char TEXT_CRASH_ASSERT[];
extern char TEXT_CRASH_DIVZERO[];
//SelectBuildServerMenu
constexpr char TEXT_SELECTBUILDSERVERMENU[] = "Select Buildserver";
constexpr char TEXT_NOBUILDSERVERCONFIGURED[] = "Not configured";
extern char TEXT_SELECTBUILDSERVERMENU[];
extern char TEXT_NOBUILDSERVERCONFIGURED[];
//Otamenu
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...";
extern char TEXT_UPDATENOW[];
extern char TEXT_SELECTBUILD[];
extern char TEXT_OTA_NOBUILDSERVERAVAILABLE[];
extern char TEXT_OTA_NOBUILDSERVERSELECTED[];
extern char TEXT_OTA_NOCONNECTION[];
extern char TEXT_OTA_WAITFORRESPONSE[];
//LedstripColorMenu
constexpr char TEXT_LEDSTRIPCOLORMENU[] = "Customize Ledstrip";
extern char TEXT_LEDSTRIPCOLORMENU[];
//StatisticsMenu
constexpr char TEXT_STATISTICSMENU[] = "Statistics";
constexpr char TEXT_STATSSAVE[] = "Save kilometers";
constexpr char TEXT_STATSCLEAR[] = "Clear current km";
extern char TEXT_STATISTICSMENU[];
extern char TEXT_STATSSAVE[];
extern char TEXT_STATSCLEAR[];
#ifdef FEATURE_CAN
constexpr char TEXT_POWERSUPPLY[] = "Powersupply";
extern char TEXT_POWERSUPPLY[];
#endif
extern char TEXT_REENABLE_MENUITEMS[];
} // namespace
using namespace bobbytexts;

6
sdkconfig_comred
View File

@ -484,9 +484,9 @@ CONFIG_ESP32_REV_MIN_0=y
CONFIG_ESP32_REV_MIN=0
CONFIG_ESP32_DPORT_WORKAROUND=y
# CONFIG_ESP32_DEFAULT_CPU_FREQ_80 is not set
CONFIG_ESP32_DEFAULT_CPU_FREQ_160=y
# CONFIG_ESP32_DEFAULT_CPU_FREQ_240 is not set
CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ=160
# CONFIG_ESP32_DEFAULT_CPU_FREQ_160 is not set
CONFIG_ESP32_DEFAULT_CPU_FREQ_240=y
CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ=240
# CONFIG_ESP32_SPIRAM_SUPPORT is not set
# CONFIG_ESP32_TRAX is not set
CONFIG_ESP32_TRACEMEM_RESERVE_DRAM=0x0

4
tools/access.sh
View File

@ -1,4 +0,0 @@
#!/bin/sh
wget -O ignore.tar.gz.gpg http://bobbycar.commanderred.xyz/ignore.tar.gz.gpg
gpg --quiet --batch --yes --decrypt --passphrase="$IGNORE_KEY" --output ./ignore.tar.gz ignore.tar.gz.gpg
tar xzf ignore.tar.gz