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

wifi configs in NVS, wifi settings menu texts implemented, lots of other fixes

Browse Source
This commit is contained in:
0xFEEDC0DE64
2021-08-10 03:37:14 +02:00
parent e88fbfd4a7
commit e559fa8b82
41 changed files with 593 additions and 518 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
config_feedc0de.cmake
View File

@ -56,10 +56,10 @@ add_definitions(
-DDPAD_5WIRESW_PROFILE2=0
-DDPAD_5WIRESW_PROFILE3=4
# -DDPAD_5WIRESW_DEBUG
-DDEFAULT_GASMIN=150
-DDEFAULT_GASMAX=1300
-DDEFAULT_BREMSMIN=200
-DDEFAULT_BREMSMAX=1500
-DDEFAULT_GASMIN=40
-DDEFAULT_GASMAX=850
-DDEFAULT_BREMSMIN=80
-DDEFAULT_BREMSMAX=1100
-DFEATURE_BLE
# -DFEATURE_BLUETOOTH
# -DFEATURE_BMS

9
main/CMakeLists.txt
View File

@ -26,13 +26,7 @@ set(headers
actions/switchscreenaction.h
actions/tempomatmodeapplycurrentpeedaction.h
actions/toggleboolaction.h
actions/wifidisconnectaction.h
actions/wifienableipv6action.h
actions/wifireconnectaction.h
actions/wifisoftapaction.h
actions/wifisoftapdisconnectaction.h
actions/wifisoftapdisconnectwifioffaction.h
actions/wifisoftapenableipv6action.h
actions/wifiscanaction.h
actions/switchprofileaction.h
actions/updateswapfrontbackaction.h
bluetoothmode.h
@ -163,6 +157,7 @@ set(headers
ota.h
serialhandler.h
settings.h
stringsettings.h
settingspersister.h
settingsutils.h
statistics.h

85
main/accessors/wifiaccessors.h
View File

@ -1,92 +1,7 @@
#pragma once
// esp-idf includes
#include <esp_wifi_types.h>
// local includes
#include "accessorinterface.h"
namespace {
struct WifiModeAccessor : public virtual AccessorInterface<wifi_mode_t>
{
wifi_mode_t getValue() const override
{
//return WiFi.getMode();
return WIFI_MODE_NULL;
}
void setValue(wifi_mode_t value) override
{
//if (!WiFi.mode(value))
//{
//Serial.println("Could not change WiFi mode!");
//}
// TODO: better error handling
}
};
struct WifiSleepAccessor : public virtual AccessorInterface<bool>
{
bool getValue() const override
{
//return WiFi.getSleep();
return false;
}
void setValue(bool value) override
{
//if (!WiFi.setSleep(value))
//{
//Serial.println("Could not set WiFi sleep!");
//}
// TODO: better error handling
}
};
//struct WifiTxPowerAccessor : public virtual AccessorInterface<wifi_power_t>
//{
// wifi_power_t getValue() const override { return WiFi.getTxPower(); }
// void setValue(wifi_power_t value) override
// {
// if (!WiFi.setTxPower(value))
// {
// //Serial.println("Could not set WiFi tx power!");
// }
// // TODO: better error handling
// }
//};
struct WifiAutoConnectAccessor : public virtual AccessorInterface<bool>
{
bool getValue() const override
{
//return WiFi.getAutoConnect();
return true;
}
void setValue(bool value) override
{
//if (!WiFi.setAutoConnect(value))
//{
//Serial.println("Could not set WiFi autoConnect!");
//}
// TODO: better error handling
}
};
struct WifiAutoReconnectAccessor : public virtual AccessorInterface<bool>
{
bool getValue() const override
{
//return WiFi.getAutoReconnect();
return true;
}
void setValue(bool value) override
{
//if (!WiFi.setAutoReconnect(value))
//{
//Serial.println("Could not set WiFi autoReconnect!");
//}
// TODO: better error handling
}
};
}

9
main/actions/erasenvsaction.h
View File

@ -23,6 +23,7 @@ public:
}
settings = presets::defaultSettings;
stringSettings = presets::makeDefaultStringSettings();
if (!settingsPersister.openCommon())
{
@ -41,7 +42,13 @@ public:
if (!settingsPersister.load(settings))
{
ESP_LOGE("BOBBY", "load() failed");
ESP_LOGE("BOBBY", "load() for settings failed");
//return;
}
if (!settingsPersister.load(stringSettings))
{
ESP_LOGE("BOBBY", "load() for stringSettings failed");
//return;
}
}

18
main/actions/wifidisconnectaction.h
View File

@ -1,18 +0,0 @@
#pragma once
#include "actioninterface.h"
namespace {
class WifiDisconnectAction : public virtual ActionInterface
{
public:
void triggered() override
{
//if (!WiFi.disconnect())
//{
//Serial.println("Could not disconnect WiFi");
// TODO: better error handling
//}
}
};
}

18
main/actions/wifienableipv6action.h
View File

@ -1,18 +0,0 @@
#pragma once
#include "actioninterface.h"
namespace {
class WifiEnableIpV6Action : public virtual ActionInterface
{
public:
void triggered() override
{
//if (!WiFi.enableIpV6())
//{
//Serial.println("Could not enableIpV6 WiFi");
// TODO: better error handling
//}
}
};
}

18
main/actions/wifireconnectaction.h
View File

@ -1,18 +0,0 @@
#pragma once
#include "actioninterface.h"
namespace {
class WifiReconnectAction : public virtual ActionInterface
{
public:
void triggered() override
{
//if (!WiFi.reconnect())
//{
//Serial.println("Could not reconnect WiFi");
// TODO: better error handling
//}
}
};
}

23
main/actions/wifiscanaction.h Normal file
View File

@ -0,0 +1,23 @@
#pragma once
// esp-idf includes
#include <esp_log.h>
// local includes
#include "actioninterface.h"
#include "wifi_bobbycar.h"
namespace {
class WifiScanAction : public virtual ActionInterface
{
public:
void triggered() override
{
if (const auto result = wifi_scan(); result != ESP_OK)
{
ESP_LOGE("BOBBY", "wifi_scan() failed with %s", esp_err_to_name(result));
return;
}
}
};
}

22
main/actions/wifisoftapaction.h
View File

@ -1,22 +0,0 @@
#pragma once
// local includes
#include "actioninterface.h"
#include "globals.h"
#include "utils.h"
#include "macros_bobbycar.h"
namespace {
class WifiSoftApAction : public virtual ActionInterface
{
public:
void triggered() override
{
//if (!WiFi.softAP(deviceName, STRING(AP_PASSWORD)))
//{
//Serial.println("Could not softAP WiFi");
// TODO: better error handling
//}
}
};
}

18
main/actions/wifisoftapdisconnectaction.h
View File

@ -1,18 +0,0 @@
#pragma once
#include "actioninterface.h"
namespace {
class WifiSoftApDisconnectAction : public virtual ActionInterface
{
public:
void triggered() override
{
//if (!WiFi.softAPdisconnect())
//{
//Serial.println("Could not softAPdisconnect WiFi");
// TODO: better error handling
//}
}
};
}

18
main/actions/wifisoftapdisconnectwifioffaction.h
View File

@ -1,18 +0,0 @@
#pragma once
#include "actioninterface.h"
namespace {
class WifiSoftApDisconnectWifioffAction : public virtual ActionInterface
{
public:
void triggered() override
{
//if (!WiFi.softAPdisconnect(true))
//{
//Serial.println("Could not softAPdisconnect wifioff WiFi");
// TODO: better error handling
//}
}
};
}

18
main/actions/wifisoftapenableipv6action.h
View File

@ -1,18 +0,0 @@
#pragma once
#include "actioninterface.h"
namespace {
class WifiSoftApEnableIpV6Action : public virtual ActionInterface
{
public:
void triggered() override
{
//if (!WiFi.softAPenableIpV6())
//{
//Serial.println("Could not softAPenableIpV6 WiFi");
// TODO: better error handling
//}
}
};
}

2
main/changevaluedisplay.h
View File

@ -133,7 +133,7 @@ void ChangeValueDisplay<float>::redraw()
tft.setTextColor(TFT_WHITE, TFT_BLACK);
tft.setTextFont(7);
m_valueLabel.redraw(fmt::format("{:02f}", m_value));
m_valueLabel.redraw(fmt::format("{:.02f}", m_value));
}
template<typename Tvalue>

9
main/displays/calibratedisplay.h
View File

@ -1,8 +1,13 @@
#pragma once
// system includes
#include <array>
#include <string>
// 3rdparty lib includes
#include <fmt/core.h>
// local includes
#include "display.h"
#include "actions/switchscreenaction.h"
#include "globals.h"
@ -137,7 +142,7 @@ void CalibrateDisplay::update()
void CalibrateDisplay::redraw()
{
m_labels[0].redraw(m_gas ? std::to_string(*m_gas) : "?");
m_labels[0].redraw(m_gas ? fmt::format("{:.02f}", *m_gas) : "?");
m_labels[1].redraw(raw_gas ? std::to_string(*raw_gas) : "?");
if (m_status == Status::GasMin)
tft.setTextColor(TFT_RED, TFT_BLACK);
@ -152,7 +157,7 @@ void CalibrateDisplay::redraw()
m_progressBars[0].redraw(m_gas ? *m_gas : 0);
m_labels[4].redraw(m_brems ? std::to_string(*m_brems) : "?");
m_labels[4].redraw(m_brems ? fmt::format("{:.02f}", *m_brems) : "?");
m_labels[5].redraw(raw_brems ? std::to_string(*raw_brems) : "?");
if (m_status == Status::BremsMin)
tft.setTextColor(TFT_RED, TFT_BLACK);

6
main/displays/gametrakcalibratedisplay.h
View File

@ -62,13 +62,13 @@ void GametrakCalibrateDisplay::initScreen()
void GametrakCalibrateDisplay::redraw()
{
m_labels[0].redraw(std::to_string(gametrakX));
m_labels[0].redraw(fmt::format("{:.02f}", gametrakX));
m_labels[1].redraw(std::to_string(raw_gametrakX));
m_labels[2].redraw(std::to_string(gametrakY));
m_labels[2].redraw(fmt::format("{:.02f}", gametrakY));
m_labels[3].redraw(std::to_string(raw_gametrakY));
m_labels[4].redraw(std::to_string(gametrakDist));
m_labels[4].redraw(fmt::format("{:.02f}", gametrakDist));
m_labels[5].redraw(std::to_string(raw_gametrakDist));
m_progressBars[0].redraw(gametrakX);

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

@ -16,7 +16,6 @@ class SettingsMenu;
namespace {
constexpr char TEXT_VERSION[] = "Version: 1.0";
constexpr char TEXT_ESPINFO[] = "ESP info:";
class AboutMenu :
public MenuDisplay,
@ -27,16 +26,14 @@ public:
AboutMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_VERSION>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPINFO>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspHeapSizeText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspFreeHeapText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspMinFreeHeapText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspMaxAllocHeapText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspPsramSizeText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspFreePsramText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspMinFreePsramText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspMaxAllocPsramText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapTotal8Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapFree8Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapMinFree8Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapLargest8Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapTotal32Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapFree32Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapMinFree32Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, HeapLargest32Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspChipRevisionText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspCpuFreqMHzText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, EspCycleCountText, StaticFont<2>, DisabledColor, DummyAction>>();

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

@ -4,10 +4,6 @@
#include "menudisplay.h"
#include "menuitem.h"
#include "actions/dummyaction.h"
#include "actions/wifisoftapaction.h"
#include "actions/wifisoftapdisconnectaction.h"
#include "actions/wifisoftapdisconnectwifioffaction.h"
#include "actions/wifisoftapenableipv6action.h"
#include "actions/switchscreenaction.h"
#include "icons/back.h"
#include "wifitexthelpers.h"
@ -27,15 +23,11 @@ class AccessPointWifiSettingsMenu :
public:
AccessPointWifiSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAP>, WifiSoftApAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECT>, WifiSoftApDisconnectAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPDISCONNECTWIFIOFF>, WifiSoftApDisconnectWifioffAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApGetStationNumText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApBroadcastIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApNetworkIdText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApSubnetCidrText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISOFTAPENABLEIPV6>, WifiSoftApEnableIpV6Action>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApIpV6Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApHostnameText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApMacAddressText, StaticFont<2>, DisabledColor, DummyAction>>();

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

@ -1,5 +1,8 @@
#pragma once
// 3rdparty lib includes
#include <fmt/core.h>
// local includes
#include "menudisplay.h"
#include "utils.h"
@ -29,7 +32,7 @@ public:
return std::string{"gas: "} +
(raw_gas ? std::to_string(*raw_gas) : "?") +
": " +
(gas ? std::to_string(*gas) : "?");
(gas ? fmt::format("{:.02f}", *gas) : "?");
}
};
struct BremsText : public virtual TextInterface {
@ -39,41 +42,41 @@ public:
return std::string{"brems: "} +
(raw_brems ? std::to_string(*raw_brems) : "?") +
": " +
(brems ? std::to_string(*brems) : "?");
(brems ? fmt::format("{:.02f}", *brems) : "?");
}
};
using SampleCountChangeScreen = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_SETSAMPLECOUNT>,
StaticText<TEXT_SAMPLECOUNT>,
SampleCountAccessor,
BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>,
SwitchScreenAction<BoardcomputerHardwareSettingsMenu>
>;
using GasMinChangeScreen = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_SETGASMIN>,
StaticText<TEXT_GASMIN>,
GasMinAccessor,
BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>,
SwitchScreenAction<BoardcomputerHardwareSettingsMenu>
>;
using GasMaxChangeScreen = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_SETGASMAX>,
StaticText<TEXT_GASMAX>,
GasMaxAccessor,
BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>,
SwitchScreenAction<BoardcomputerHardwareSettingsMenu>
>;
using BremsMinChangeScreen = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_SETBREMSMIN>,
StaticText<TEXT_BREMSMIN>,
BremsMinAccessor,
BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>,
SwitchScreenAction<BoardcomputerHardwareSettingsMenu>
>;
using BremsMaxChangeScreen = makeComponent<
ChangeValueDisplay<int16_t>,
StaticText<TEXT_SETBREMSMAX>,
StaticText<TEXT_BREMSMAX>,
BremsMaxAccessor,
BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>,
SwitchScreenAction<BoardcomputerHardwareSettingsMenu>
@ -82,7 +85,7 @@ using BremsMaxChangeScreen = makeComponent<
#if defined(FEATURE_DPAD) || defined(FEATURE_DPAD_3WIRESW) || defined(FEATURE_DPAD_5WIRESW)
using DPadDebounceChangeScreen = makeComponent<
ChangeValueDisplay<uint8_t>,
StaticText<TEXT_SETDPADDEBOUNCE>,
StaticText<TEXT_DPADDEBOUNCE>,
DPadDebounceAccessor,
BackActionInterface<SwitchScreenAction<BoardcomputerHardwareSettingsMenu>>,
SwitchScreenAction<BoardcomputerHardwareSettingsMenu>
@ -92,15 +95,15 @@ using DPadDebounceChangeScreen = makeComponent<
#ifdef FEATURE_GAMETRAK
struct GametrakXText : public virtual TextInterface {
public:
std::string text() const override { return std::string{"gametrakX: "} + std::to_string(raw_gametrakX) + ": " + std::to_string(gametrakX); }
std::string text() const override { return fmt::format("gametrakX: {}: {:.02f}", raw_gametrakX, gametrakX); }
};
struct GametrakYText : public virtual TextInterface {
public:
std::string text() const override { return std::string{"gametrakY: "} + std::to_string(raw_gametrakY) + ": " + std::to_string(gametrakY); }
std::string text() const override { return fmt::format("gametrakY: {}: {:.02f}", raw_gametrakY, gametrakY); }
};
struct GametrakDistText : public virtual TextInterface {
public:
std::string text() const override { return std::string{"gametrakDist: "} + std::to_string(raw_gametrakDist) + ": " + std::to_string(gametrakDist); }
std::string text() const override { return fmt::format("gametrakDist: {}: {:.02f}", raw_gametrakDist, gametrakDist); }
};
using GametrakXMinChangeScreen = makeComponent<
@ -155,34 +158,34 @@ class BoardcomputerHardwareSettingsMenu :
public:
BoardcomputerHardwareSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, GasText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, BremsText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CALIBRATE>, SwitchScreenAction<CalibrateDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETSAMPLECOUNT>, SwitchScreenAction<SampleCountChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMIN>, SwitchScreenAction<GasMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGASMAX>, SwitchScreenAction<GasMaxChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMIN>, SwitchScreenAction<BremsMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETBREMSMAX>, SwitchScreenAction<BremsMaxChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, GasText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, BremsText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CALIBRATE>, SwitchScreenAction<CalibrateDisplay>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_SAMPLECOUNT, SampleCountAccessor>, SwitchScreenAction<SampleCountChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_GASMIN, GasMinAccessor>, SwitchScreenAction<GasMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_GASMAX, GasMaxAccessor>, SwitchScreenAction<GasMaxChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_BREMSMIN, BremsMinAccessor>, SwitchScreenAction<BremsMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_BREMSMAX, BremsMaxAccessor>, SwitchScreenAction<BremsMaxChangeScreen>>>();
#if defined(FEATURE_DPAD) || defined(FEATURE_DPAD_3WIRESW) || defined(FEATURE_DPAD_5WIRESW)
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETDPADDEBOUNCE>, SwitchScreenAction<DPadDebounceChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, TextWithValueHelper<TEXT_DPADDEBOUNCE, DPadDebounceAccessor>, SwitchScreenAction<DPadDebounceChangeScreen>>>();
#endif
#ifdef FEATURE_GAMETRAK
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>,
constructMenuItem<makeComponent<MenuItem, GametrakXText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, GametrakYText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, GametrakDistText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAKCALIBRATE>, SwitchScreenAction<GametrakCalibrateDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKXMIN>, SwitchScreenAction<GametrakXMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKXMAX>, SwitchScreenAction<GametrakXMaxChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKYMIN>, SwitchScreenAction<GametrakYMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKYMAX>, SwitchScreenAction<GametrakYMaxChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMIN>, SwitchScreenAction<GametrakDistMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMAX>, SwitchScreenAction<GametrakDistMaxChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>,
constructMenuItem<makeComponent<MenuItem, GametrakXText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, GametrakYText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, GametrakDistText, DisabledColor, StaticFont<2>, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GAMETRAKCALIBRATE>, SwitchScreenAction<GametrakCalibrateDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKXMIN>, SwitchScreenAction<GametrakXMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKXMAX>, SwitchScreenAction<GametrakXMaxChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKYMIN>, SwitchScreenAction<GametrakYMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKYMAX>, SwitchScreenAction<GametrakYMaxChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMIN>, SwitchScreenAction<GametrakDistMinChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SETGAMETRAKDISTMAX>, SwitchScreenAction<GametrakDistMaxChangeScreen>>>();
#endif
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPSCREENBYTES>, ToggleBoolAction, CheckboxIcon, SwapScreenBytesAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TIMERS>, SwitchScreenAction<TimersMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
constructMenuItem<makeComponent<MenuItem, EmptyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SWAPSCREENBYTES>, ToggleBoolAction, CheckboxIcon, SwapScreenBytesAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_TIMERS>, SwitchScreenAction<TimersMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
};
} // namespace

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

@ -6,6 +6,7 @@
// 3rdparty lib includes
#include <espchrono.h>
#include <fmt/core.h>
// local includes
#include "menudisplay.h"
@ -33,7 +34,7 @@ public:
const auto now = espchrono::millis_clock::now();
if (!m_nextUpdate || now >= *m_nextUpdate)
{
m_title = "Dynamic text: " + std::to_string(random(0, 100));
m_title = fmt::format("Dynamic text: {}", random(0, 100));
m_nextUpdate = now + std::chrono::milliseconds{random(0, 1000)};
}

21
main/displays/menus/genericwifisettingsmenu.h
View File

@ -20,22 +20,6 @@ class WifiSettingsMenu;
} // namespace
namespace {
using WifiModeChangeScreen = makeComponent<
ChangeValueDisplay<wifi_mode_t>,
StaticText<TEXT_WIFICHANGEMODE>,
WifiModeAccessor,
BackActionInterface<SwitchScreenAction<GenericWifiSettingsMenu>>,
SwitchScreenAction<GenericWifiSettingsMenu>
>;
//using WifiTxPowerChangeScreen = makeComponent<
// ChangeValueDisplay<wifi_power_t>,
// StaticText<TEXT_WIFICHANGETXPOWER>,
// WifiTxPowerAccessor,
// BackActionInterface<SwitchScreenAction<GenericWifiSettingsMenu>>,
// SwitchScreenAction<GenericWifiSettingsMenu>
//>;
class GenericWifiSettingsMenu :
public MenuDisplay,
public StaticText<TEXT_GENERICWIFISETTINGS>,
@ -44,11 +28,6 @@ class GenericWifiSettingsMenu :
public:
GenericWifiSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, WifiStatusBitsText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiChannelText, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEMODE>, SwitchScreenAction<WifiModeChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGESLEEP>, ToggleBoolAction, CheckboxIcon, WifiSleepAccessor>>();
//constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGETXPOWER>, SwitchScreenAction<WifiTxPowerChangeScreen>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
};

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

@ -146,6 +146,14 @@ using MotorCurrentsGraphDisplay = makeComponent<
BackActionInterface<SwitchScreenAction<GraphsMenu>>
>;
using RssiGraphDisplay = makeComponent<
GraphDisplay<1>,
StaticText<TEXT_RSSI>,
SingleGraphAccessor<RssiStatistics>,
ConfirmActionInterface<SwitchScreenAction<GraphsMenu>>,
BackActionInterface<SwitchScreenAction<GraphsMenu>>
>;
class GraphsMenu :
public MenuDisplay,
public StaticText<TEXT_GRAPHS>,
@ -172,6 +180,7 @@ public:
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_SUMCURRENTSCOMPARISON>, SwitchScreenAction<SumCurrentsComparisonGraphDisplay>>>();
#endif
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_MOTORCURRENTS>, SwitchScreenAction<MotorCurrentsGraphDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_RSSI>, SwitchScreenAction<RssiGraphDisplay>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<MainMenu>, StaticMenuItemIcon<&icons::back>>>();
}
};

51
main/displays/menus/stationwifisettingsmenu.h
View File

@ -6,18 +6,19 @@
#include "menuitem.h"
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "actions/wifireconnectaction.h"
#include "actions/wifidisconnectaction.h"
#include "actions/wifiscanaction.h"
#include "actions/toggleboolaction.h"
#include "actions/wifienableipv6action.h"
#include "checkboxicon.h"
#include "icons/scan.h"
#include "icons/back.h"
#include "wifitexthelpers.h"
#include "accessors/wifiaccessors.h"
#include "accessors/settingsaccessors.h"
#include "texts.h"
// forward declares
namespace {
class WifiScanMenu;
class WifiSettingsMenu;
} // namespace
@ -30,28 +31,28 @@ class StationWifiSettingsMenu :
public:
StationWifiSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIRECONNECT>, WifiReconnectAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIDISCONNECT>, WifiDisconnectAction>>();
constructMenuItem<makeComponent<MenuItem, WifiIsConnectedText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTOCONNECT>, ToggleBoolAction, CheckboxIcon, WifiAutoConnectAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFICHANGEAUTORECONNECT>, ToggleBoolAction, CheckboxIcon, WifiAutoReconnectAccessor>>();
constructMenuItem<makeComponent<MenuItem, WifiLocalIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiMacAddressText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSubnetMaskText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiGatewayIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiDnsIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiBroadcastIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiNetworkIdText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSubnetCIDRText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIENABLEIPV6>, WifiEnableIpV6Action>>();
constructMenuItem<makeComponent<MenuItem, WifiLocalIpV6Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiHostnameText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStatusText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSsidText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiPskText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiBssidText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiRssiText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIENABLED>, ToggleBoolAction, CheckboxIcon, WifiEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFITRIGGERSCAN>, WifiScanAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISCANRESULTS>, SwitchScreenAction<WifiScanMenu>, StaticMenuItemIcon<&icons::scan>>>();
constructMenuItem<makeComponent<MenuItem, WifiStatusText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiScanStatusText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiHostnameText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiMacText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSsidText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiBssidText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiRssiText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiEncryptionTypeText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiPairwiseCipherText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiGroupCipherText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiIpText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiNetmaskText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiGatewayText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiIpv6LinklocalText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiIpv6GlobalText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiDns0Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiDns1Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiDns2Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
};
} // namespace

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

@ -23,13 +23,13 @@
// forward declares
namespace {
class WifiSettingsMenu;
class StationWifiSettingsMenu;
} // namespace
using namespace std::chrono_literals;
namespace {
class WifiScanMenu : public MenuDisplay, public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
class WifiScanMenu : public MenuDisplay, public BackActionInterface<SwitchScreenAction<StationWifiSettingsMenu>>
{
using Base = MenuDisplay;
@ -50,7 +50,7 @@ private:
WifiScanMenu::WifiScanMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<StationWifiSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
std::string WifiScanMenu::text() const

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

@ -1,22 +1,16 @@
#pragma once
// local includes
#include "changevaluedisplay.h"
#include "menudisplay.h"
#include "utils.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "icons/scan.h"
#include "icons/back.h"
#include "texts.h"
#include "accessors/settingsaccessors.h"
// forward declares
namespace {
class GenericWifiSettingsMenu;
class StationWifiSettingsMenu;
class WifiScanMenu;
class AccessPointWifiSettingsMenu;
class SettingsMenu;
} // namespace
@ -32,10 +26,8 @@ class WifiSettingsMenu :
public:
WifiSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIENABLED>, ToggleBoolAction, CheckboxIcon, WifiEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GENERICWIFISETTINGS>, SwitchScreenAction<GenericWifiSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATIONWIFISETTINGS>, SwitchScreenAction<StationWifiSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISCAN>, SwitchScreenAction<WifiScanMenu>, StaticMenuItemIcon<&icons::scan>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ACCESSPOINTWIFISETTINGS>, SwitchScreenAction<AccessPointWifiSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}

86
main/displays/statusdisplay.h
View File

@ -1,11 +1,11 @@
#pragma once
// system includes
#include <optional>
// esp-idf includes
#include <esp_heap_caps.h>
// 3rdparty lib includes
#include <fmt/core.h>
#include <espchrono.h>
#include <espwifistack.h>
// local includes
#include "display.h"
@ -100,22 +100,15 @@ private:
Label m_labelWifiStatus{35, bottomLines[0]}; // 120, 15
Label m_labelLimit0{205, bottomLines[0]}; // 35, 15
Label m_labelIpAddress{25, bottomLines[1]}; // 130, 15
Label m_labelSignal{125, bottomLines[1]}; // 130, 15
Label m_labelLimit1{205, bottomLines[1]}; // 35, 15
Label m_labelPerformance{85, bottomLines[2]}; // 40, 15
Label m_labelPerformance{40, bottomLines[2]}; // 40, 15
Label m_labelFreeMem{70, bottomLines[2]}; // 40, 15
Label m_labelMode{165, bottomLines[2]}; // 75, 15
Label m_labelName{40, bottomLines[3]}; // 40, 15
Label m_labelProfile{205, bottomLines[3]}; // 35, 15
static const constexpr int bottomLines[4] { 251, 266, 281, 296 };
struct CachedString
{
std::string text;
espchrono::millis_clock::time_point timestamp = espchrono::millis_clock::now();
};
std::optional<CachedString> m_cachedWifiStatus;
std::optional<CachedString> m_cachedWifiIP;
};
void StatusDisplay::initScreen()
@ -143,10 +136,12 @@ void StatusDisplay::initScreen()
m_labelLimit0.start();
tft.drawString("IP:", 0, bottomLines[1]);
m_labelIpAddress.start();
m_labelSignal.start();
tft.drawString("Limit1:", 160, bottomLines[1]);
m_labelLimit1.start();
tft.drawString("Performance:", 0, bottomLines[2]);
tft.drawString("Perf:", 0, bottomLines[2]);
m_labelPerformance.start();
m_labelFreeMem.start();
tft.drawString("Mode:", 125, bottomLines[2]);
m_labelMode.start();
tft.drawString("Name:", 0, bottomLines[3]);
@ -154,9 +149,6 @@ void StatusDisplay::initScreen()
m_labelProfile.start();
tft.setTextColor(TFT_WHITE, TFT_BLACK);
m_cachedWifiStatus = std::nullopt;
m_cachedWifiIP = std::nullopt;
}
void StatusDisplay::redraw()
@ -174,38 +166,60 @@ void StatusDisplay::redraw()
tft.setTextFont(2);
if (!m_cachedWifiStatus || espchrono::ago(m_cachedWifiStatus->timestamp) >= 500ms)
const auto staStatus = wifi_stack::get_sta_status();
if (staStatus == wifi_stack::WiFiStaStatus::WL_CONNECTED)
{
const auto staStatus = wifi_stack::get_sta_status();
if (staStatus == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto result = wifi_stack::get_sta_ap_info(); result)
{
if (const auto result = wifi_stack::get_sta_ap_info(); result)
{
m_cachedWifiStatus = CachedString{ .text = std::string{reinterpret_cast<const char*>(result->ssid)} };
}
else
{
ESP_LOGW("BOBBY", "get_sta_ap_info() failed with %.*s", result.error().size(), result.error().data());
goto showStaStatus;
}
m_labelWifiStatus.redraw(std::string_view{reinterpret_cast<const char*>(result->ssid)});
tft.setTextColor(result->rssi < -80 ? TFT_ORANGE : TFT_WHITE, TFT_BLACK);
m_labelSignal.redraw(fmt::format("{}dB", result->rssi));
tft.setTextColor(TFT_WHITE, TFT_BLACK);
}
else
{
showStaStatus:
m_cachedWifiStatus = CachedString{ .text = wifi_stack::toString(staStatus) };
ESP_LOGW("BOBBY", "get_sta_ap_info() failed with %.*s", result.error().size(), result.error().data());
goto showStaStatus;
}
}
assert(m_cachedWifiStatus);
m_labelWifiStatus.redraw(m_cachedWifiStatus->text);
else
{
showStaStatus:
m_labelWifiStatus.redraw(wifi_stack::toString(staStatus));
m_labelSignal.clear();
}
m_labelLimit0.redraw(fmt::format("{}A", controllers.front.command.left.iMotMax));
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA))
m_labelIpAddress.redraw(wifi_stack::toString(result->ip));
if (staStatus == wifi_stack::WiFiStaStatus::WL_CONNECTED)
{
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
m_labelIpAddress.redraw(wifi_stack::toString(result->ip));
else
{
ESP_LOGW("BOBBY", "get_ip_info() failed with %.*s", result.error().size(), result.error().data());
goto clearIp;
}
}
else
{
clearIp:
m_labelIpAddress.clear();
}
m_labelLimit1.redraw(fmt::format("{}A", controllers.front.command.left.iDcMax));
tft.setTextColor(performance.last < 35 ? TFT_ORANGE : TFT_WHITE, TFT_BLACK);
m_labelPerformance.redraw(std::to_string(performance.last));
tft.setTextColor(TFT_WHITE, TFT_BLACK);
{
const auto freeMem = heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
tft.setTextColor(freeMem < 70000 ? TFT_ORANGE : TFT_WHITE, TFT_BLACK);
m_labelFreeMem.redraw(fmt::format("{}K", freeMem/1000));
tft.setTextColor(TFT_WHITE, TFT_BLACK);
}
m_labelMode.redraw(currentMode->displayName());
m_labelName.redraw(deviceName);
const auto profile = settingsPersister.currentlyOpenProfileIndex();

6
main/displays/updatedisplay.h
View File

@ -1,12 +1,16 @@
#pragma once
// system includes
#include <array>
#include <string>
// 3rdparty lib includes
#ifdef FEATURE_OTA
#include <espasyncota.h>
#endif
#include <fmt/core.h>
// local includes
#include "display.h"
#include "actions/switchscreenaction.h"
#include "globals.h"
@ -80,7 +84,7 @@ void UpdateDisplay::initScreen()
void UpdateDisplay::redraw()
{
m_progressLabel.redraw(std::to_string(m_progress) + '/' + std::to_string(m_total));
m_progressLabel.redraw(fmt::format("{}/{}", m_progress, m_total));
m_progressBar.redraw(float(m_progress) / m_total * 100.f);
}

39
main/esptexthelpers.h
View File

@ -1,34 +1,41 @@
#pragma once
// esp-idf includes
#include <esp_heap_caps.h>
// 3rdparty lib includes
#include <fmt/core.h>
// local includes
#include "textinterface.h"
namespace {
//template<const char *Ttext, typename TreturnType, TreturnType (EspClass::*Tmethod)()>
//using EspStatusTextHelper = StatusTextHelper<Ttext, EspClass, &ESP, TreturnType, Tmethod>;
constexpr char TEXT_ESPHEAPSIZE[] = "Heap size: ";
using EspHeapSizeText = StaticText<TEXT_ESPHEAPSIZE>; //EspStatusTextHelper<TEXT_ESPHEAPSIZE, uint32_t, &EspClass::getHeapSize>;
class HeapTotal8Text : public virtual TextInterface { public: std::string text() const override {
return fmt::format("HeapTotal8: {}", heap_caps_get_total_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)); }};
constexpr char TEXT_ESPFREEHEAP[] = "Free heap: ";
using EspFreeHeapText = StaticText<TEXT_ESPFREEHEAP>; //EspStatusTextHelper<TEXT_ESPFREEHEAP, uint32_t, &EspClass::getFreeHeap>;
class HeapFree8Text : public virtual TextInterface { public: std::string text() const override {
return fmt::format("HeapFree8: {}", heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)); }};
constexpr char TEXT_ESPMINFREEHEAP[] = "Min free heap: ";
using EspMinFreeHeapText = StaticText<TEXT_ESPMINFREEHEAP>; //EspStatusTextHelper<TEXT_ESPMINFREEHEAP, uint32_t, &EspClass::getMinFreeHeap>;
class HeapMinFree8Text : public virtual TextInterface { public: std::string text() const override {
return fmt::format("HeapMinFree8: {}", heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)); }};
constexpr char TEXT_ESPMAXALLOCHEAP[] = "Max alloc heap: ";
using EspMaxAllocHeapText = StaticText<TEXT_ESPMAXALLOCHEAP>; //EspStatusTextHelper<TEXT_ESPMAXALLOCHEAP, uint32_t, &EspClass::getMaxAllocHeap>;
class HeapLargest8Text : public virtual TextInterface { public: std::string text() const override {
return fmt::format("HeapLargest8: {}", heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)); }};
constexpr char TEXT_ESPPSRAMSIZE[] = "psram size: ";
using EspPsramSizeText = StaticText<TEXT_ESPPSRAMSIZE>; //EspStatusTextHelper<TEXT_ESPPSRAMSIZE, uint32_t, &EspClass::getPsramSize>;
class HeapTotal32Text : public virtual TextInterface { public: std::string text() const override {
return fmt::format("HeapTotal32: {}", heap_caps_get_total_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_32BIT)); }};
constexpr char TEXT_ESPFREEPSRAM[] = "Free psram: ";
using EspFreePsramText = StaticText<TEXT_ESPFREEPSRAM>; //EspStatusTextHelper<TEXT_ESPFREEPSRAM, uint32_t, &EspClass::getFreePsram>;
class HeapFree32Text : public virtual TextInterface { public: std::string text() const override {
return fmt::format("HeapFree32: {}", heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_32BIT)); }};
constexpr char TEXT_ESPMINFREEPSRAM[] = "Min free psram: ";
using EspMinFreePsramText = StaticText<TEXT_ESPMINFREEPSRAM>; //EspStatusTextHelper<TEXT_ESPMINFREEPSRAM, uint32_t, &EspClass::getMinFreePsram>;
class HeapMinFree32Text : public virtual TextInterface { public: std::string text() const override {
return fmt::format("HeapMinFree32: {}", heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_32BIT)); }};
constexpr char TEXT_ESPMAXALLOCPSRAM[] = "Max alloc psram: ";
using EspMaxAllocPsramText = StaticText<TEXT_ESPMAXALLOCPSRAM>; //EspStatusTextHelper<TEXT_ESPMAXALLOCPSRAM, uint32_t, &EspClass::getMaxAllocPsram>;
class HeapLargest32Text : public virtual TextInterface { public: std::string text() const override {
return fmt::format("HeapLargest32: {}", heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL|MALLOC_CAP_32BIT)); }};
constexpr char TEXT_ESPCHIPREVISION[] = "Chip revision: ";
using EspChipRevisionText = StaticText<TEXT_ESPCHIPREVISION>; //EspStatusTextHelper<TEXT_ESPCHIPREVISION, uint8_t, &EspClass::getChipRevision>;

2
main/globals.h
View File

@ -23,6 +23,7 @@
#include "display.h"
#include "modeinterface.h"
#include "settings.h"
#include "stringsettings.h"
#include "settingspersister.h"
#include "macros_bobbycar.h"
@ -39,6 +40,7 @@ float avgSpeed, avgSpeedKmh, sumCurrent;
char deviceName[32] = STRING(DEVICE_PREFIX) "_ERR";
Settings settings;
StringSettings stringSettings;
SettingsPersister settingsPersister;
constexpr auto TFT_GREY = 0x5AEB;

31
main/main.cpp
View File

@ -81,7 +81,6 @@ using namespace std::chrono_literals;
#include "ota.h"
#include "presets.h"
#include "statistics.h"
#include "actions/wifisoftapaction.h"
#ifdef FEATURE_BLUETOOTH
#include "actions/bluetoothbeginaction.h"
#include "actions/bluetoothbeginmasteraction.h"
@ -116,14 +115,6 @@ std::optional<espchrono::millis_clock::time_point> lastBleUpdate;
#endif
}
void printMemoryStats(const char *s)
{
//Serial.printf("MEMORY %s 8bit: %u 32bit: %u\r\n",
// s,
// heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT),
// heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_32BIT));
}
extern "C" void app_main()
{
Serial.begin(115200);
@ -135,14 +126,11 @@ extern "C" void app_main()
digitalWrite(PINS_LEDBACKLIGHT, ledBacklightInverted ? LOW : HIGH);
#endif
printMemoryStats("setup()");
pinMode(3, INPUT_PULLUP);
currentlyReverseBeeping = false;
initScreen();
printMemoryStats("initScreen()");
#ifdef FEATURE_DPAD
bootLabel.redraw("dpad");
@ -177,6 +165,7 @@ extern "C" void app_main()
bootLabel.redraw("settings");
settings = presets::defaultSettings;
stringSettings = presets::makeDefaultStringSettings();
if (settingsPersister.init())
{
@ -191,23 +180,18 @@ extern "C" void app_main()
else
ESP_LOGE("BOBBY", "init() failed");
printMemoryStats("loadSettings()");
bootLabel.redraw("deviceName");
if (const auto result = wifi_stack::get_default_mac_addr())
std::sprintf(deviceName, STRING(DEVICE_PREFIX) "_%02hhx%02hhx%02hhx", result->at(3), result->at(4), result->at(5));
else
ESP_LOGE("MAIN", "get_default_mac_addr() failed: %.*s", result.error().size(), result.error().data());
printMemoryStats("deviceName");
bootLabel.redraw("wifi");
wifi_begin();
printMemoryStats("wifi_begin()");
#ifdef FEATURE_SERIAL
bootLabel.redraw("swap front back");
updateSwapFrontBack();
printMemoryStats("swapFronBack()");
#endif
#ifdef FEATURE_BLUETOOTH
@ -215,13 +199,11 @@ extern "C" void app_main()
{
bootLabel.redraw("bluetooth begin master");
BluetoothBeginMasterAction{}.triggered();
printMemoryStats("BluetoothBeginMasterAction()");
#ifdef FEATURE_BMS
if (settings.autoConnectBms)
{
bootLabel.redraw("connect BMS");
BluetoothConnectBmsAction{}.triggered();
printMemoryStats("BluetoothConnectBmsAction()");
}
#endif
}
@ -229,7 +211,6 @@ extern "C" void app_main()
{
bootLabel.redraw("bluetooth begin");
BluetoothBeginAction{}.triggered();
printMemoryStats("BluetoothBeginAction()");
}
#endif
@ -258,29 +239,24 @@ extern "C" void app_main()
#ifdef FEATURE_OTA
bootLabel.redraw("ota");
initOta();
printMemoryStats("initOta()");
#endif
#ifdef FEATURE_BLE
bootLabel.redraw("ble");
initBle();
printMemoryStats("initBle()");
#endif
#ifdef FEATURE_WEBSERVER
bootLabel.redraw("webserver");
initWebserver();
printMemoryStats("initWebserver()");
#endif
bootLabel.redraw("potis");
readPotis();
printMemoryStats("readPotis()");
#ifdef FEATURE_CLOUD
bootLabel.redraw("startCloud");
startCloud();
printMemoryStats("readPotis()");
#endif
bootLabel.redraw("switchScreen");
@ -295,13 +271,8 @@ extern "C" void app_main()
switchScreen<StatusDisplay>();
#endif
printMemoryStats("switchScreen()");
while (true)
{
//Serial.println("loop()");
//printMemoryStats("loop()");
const auto now = espchrono::millis_clock::now();
if (!lastWifiUpdate || now - *lastWifiUpdate >= 100ms)

24
main/presets.h
View File

@ -1,6 +1,8 @@
#pragma once
// local includes
#include "settings.h"
#include "stringsettings.h"
namespace presets {
constexpr Settings::Limits defaultLimits {
@ -167,7 +169,7 @@ constexpr Settings::LarsmMode defaultLarsmMode {
.iterations = 100
};
constexpr Settings defaultSettings{
constexpr Settings defaultSettings {
#ifdef FEATURE_BMS
.autoConnectBms = false,
#endif
@ -187,4 +189,24 @@ constexpr Settings defaultSettings{
.tempomatMode = defaultTempomatMode,
.larsmMode = defaultLarsmMode
};
StringSettings makeDefaultStringSettings()
{
using ConfiguredWifi = StringSettings::ConfiguredWifi;
return {
.wifis = std::array<ConfiguredWifi, 10> {
ConfiguredWifi { .ssid = {}, .key = {} },
ConfiguredWifi { .ssid = {}, .key = {} },
ConfiguredWifi { .ssid = {}, .key = {} },
ConfiguredWifi { .ssid = {}, .key = {} },
ConfiguredWifi { .ssid = {}, .key = {} },
ConfiguredWifi { .ssid = {}, .key = {} },
ConfiguredWifi { .ssid = {}, .key = {} },
ConfiguredWifi { .ssid = {}, .key = {} },
ConfiguredWifi { .ssid = {}, .key = {} },
ConfiguredWifi { .ssid = {}, .key = {} }
}
};
}
}

5
main/settings.h
View File

@ -1,11 +1,14 @@
#pragma once
// system includes
#include <cstdint>
#include <array>
// esp-idf includes
#include <esp_wifi_types.h>
// local includes
#include "bobbycar-common.h"
#ifdef FEATURE_BLUETOOTH
#include "bluetoothmode.h"
#endif

40
main/settingspersister.h
View File

@ -26,8 +26,12 @@ public:
void closeCommon();
bool openProfile(uint8_t index);
void closeProfile();
bool load(Settings &settings);
bool save(Settings &settings);
template<typename T>
bool load(T &settings);
template<typename T>
bool save(T &settings);
std::optional<uint8_t> currentlyOpenProfileIndex() const;
@ -141,6 +145,20 @@ template<> struct nvsGetterHelper<int16_t> { static constexpr auto nvs_get = &nv
template<> struct nvsGetterHelper<uint16_t> { static constexpr auto nvs_get = &nvs_get_u16; };
template<> struct nvsGetterHelper<int32_t> { static constexpr auto nvs_get = &nvs_get_i32; };
template<> struct nvsGetterHelper<uint32_t> { static constexpr auto nvs_get = &nvs_get_u32; };
template<> struct nvsGetterHelper<std::string> { static esp_err_t nvs_get(nvs_handle handle, const char* key, std::string* out_value)
{
size_t length;
if (const esp_err_t result = nvs_get_str(handle, key, nullptr, &length); result != ESP_OK)
return result;
char buf[length];
if (const esp_err_t result = nvs_get_str(handle, key, buf, &length); result != ESP_OK)
return result;
*out_value = buf;
return ESP_OK;
}};
template<> struct nvsGetterHelper<bool> { static esp_err_t nvs_get(nvs_handle handle, const char* key, bool* out_value)
{
uint8_t tempValue;
@ -200,7 +218,8 @@ template<> struct nvsGetterHelper<wifi_mode_t> { static esp_err_t nvs_get(nvs_ha
return err;
}};
bool SettingsPersister::load(Settings &settings)
template<typename T>
bool SettingsPersister::load(T &settings)
{
bool result{true};
@ -210,7 +229,8 @@ bool SettingsPersister::load(Settings &settings)
{
if (esp_err_t result = nvsGetterHelper<std::remove_reference_t<decltype(value)>>::nvs_get(m_handle, key, &value); result != ESP_OK)
{
ESP_LOGE("BOBBY", "nvs_get() COMMON %s failed with %s", key, esp_err_to_name(result));
if (result != ESP_ERR_NVS_NOT_FOUND)
ESP_LOGE("BOBBY", "nvs_get() COMMON %s failed with %s", key, esp_err_to_name(result));
result = false;
}
});
@ -227,7 +247,8 @@ bool SettingsPersister::load(Settings &settings)
{
if (esp_err_t result = nvsGetterHelper<std::remove_reference_t<decltype(value)>>::nvs_get(m_profile->handle, key, &value); result != ESP_OK)
{
ESP_LOGE("BOBBY", "nvs_get() PROFILE %s failed with %s", key, esp_err_to_name(result));
if (result != ESP_ERR_NVS_NOT_FOUND)
ESP_LOGE("BOBBY", "nvs_get() PROFILE %s failed with %s", key, esp_err_to_name(result));
result = false;
}
});
@ -249,6 +270,10 @@ template<> struct nvsSetterHelper<uint16_t> { static constexpr auto nvs_set = &n
template<> struct nvsSetterHelper<int32_t> { static constexpr auto nvs_set = &nvs_set_i32; };
template<> struct nvsSetterHelper<uint32_t> { static constexpr auto nvs_set = &nvs_set_u32; };
template<> struct nvsSetterHelper<bool> { static constexpr auto nvs_set = &nvs_set_u8; };
template<> struct nvsSetterHelper<std::string> { static esp_err_t nvs_set(nvs_handle handle, const char* key, const std::string &value)
{
return nvs_set_str(handle, key, value.c_str());
}};
template<> struct nvsSetterHelper<bobbycar::protocol::ControlType> { static esp_err_t nvs_set(nvs_handle handle, const char* key, bobbycar::protocol::ControlType value)
{
return nvs_set_u8(handle, key, uint8_t(value));
@ -276,7 +301,8 @@ template<> struct nvsSetterHelper<wifi_mode_t> { static esp_err_t nvs_set(nvs_ha
return nvs_set_u8(handle, key, uint8_t(value));
}};
bool SettingsPersister::save(Settings &settings)
template<typename T>
bool SettingsPersister::save(T &settings)
{
bool result{true};
@ -286,7 +312,7 @@ bool SettingsPersister::save(Settings &settings)
{
if (esp_err_t result = nvsSetterHelper<decltype(value)>::nvs_set(m_handle, key, value); result != ESP_OK)
{
ESP_LOGE("BOBBY", "nvs_set() PROFILE %s failed with %s", key, esp_err_to_name(result));
ESP_LOGE("BOBBY", "nvs_set() COMMON %s failed with %s", key, esp_err_to_name(result));
result = false;
}
});

9
main/settingsutils.h
View File

@ -11,6 +11,7 @@ namespace {
void switchProfile(uint8_t index)
{
settings = presets::defaultSettings;
stringSettings = presets::makeDefaultStringSettings();
if (!settingsPersister.openProfile(index))
{
@ -20,7 +21,13 @@ void switchProfile(uint8_t index)
if (!settingsPersister.load(settings))
{
ESP_LOGE("BOBBY", "load() failed");
ESP_LOGE("BOBBY", "load() for settings failed");
return;
}
if (!settingsPersister.load(stringSettings))
{
ESP_LOGE("BOBBY", "load() for stringSettings failed");
return;
}
}

17
main/statistics.h
View File

@ -1,7 +1,10 @@
#pragma once
#include "ring-buffer.h"
// 3rdparty lib includes
#include <ring-buffer.h>
#include <espwifistack.h>
// local includes
#include "globals.h"
#include "bmsutils.h"
#include "utils.h"
@ -9,11 +12,11 @@
namespace {
namespace statistics {
using ContainerType = ring_buffer<float, 200>;
ContainerType gas, brems, avgSpeed, avgSpeedKmh, sumCurrent, frontVoltage, backVoltage, frontLeftCurrent, frontRightCurrent, backLeftCurrent, backRightCurrent
ContainerType gas, brems, avgSpeed, avgSpeedKmh, sumCurrent, frontVoltage, backVoltage, frontLeftCurrent, frontRightCurrent, backLeftCurrent, backRightCurrent,
#ifdef FEATURE_BMS
, bmsVoltage, bmsCurrent, bmsPower
bmsVoltage, bmsCurrent, bmsPower,
#endif
;
rssi;
}
void pushStats()
@ -42,6 +45,11 @@ void pushStats()
statistics::bmsCurrent.push_back(bms::current);
statistics::bmsPower.push_back(bms::power);
#endif
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
{
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
statistics::rssi.push_back(result->rssi);
}
}
class StatisticsAccessorInterface
@ -73,4 +81,5 @@ using FrontLeftCurrentStatistics = BufferAccessorImpl<statistics::frontLeftCurre
using FrontRightCurrentStatistics = BufferAccessorImpl<statistics::frontRightCurrent>;
using BackLeftCurrentStatistics = BufferAccessorImpl<statistics::backLeftCurrent>;
using BackRightCurrentStatistics = BufferAccessorImpl<statistics::backRightCurrent>;
using RssiStatistics = BufferAccessorImpl<statistics::rssi>;
}

53
main/stringsettings.h Normal file
View File

@ -0,0 +1,53 @@
#pragma once
// system includes
#include <array>
namespace {
struct StringSettings
{
struct ConfiguredWifi {
std::string ssid;
std::string key;
};
std::array<ConfiguredWifi, 10> wifis;
template<typename T>
void executeForEveryCommonSetting(T &&callable);
template<typename T>
void executeForEveryProfileSetting(T &&callable);
};
template<typename T>
void StringSettings::executeForEveryCommonSetting(T &&callable)
{
callable("ssid0", wifis[0].ssid);
callable("key0", wifis[0].key);
callable("ssid1", wifis[1].ssid);
callable("key1", wifis[1].key);
callable("ssid2", wifis[2].ssid);
callable("key2", wifis[2].key);
callable("ssid3", wifis[3].ssid);
callable("key3", wifis[3].key);
callable("ssid4", wifis[4].ssid);
callable("key4", wifis[4].key);
callable("ssid5", wifis[5].ssid);
callable("key5", wifis[5].key);
callable("ssid6", wifis[6].ssid);
callable("key6", wifis[6].key);
callable("ssid7", wifis[7].ssid);
callable("key7", wifis[7].key);
callable("ssid8", wifis[8].ssid);
callable("key8", wifis[8].key);
callable("ssid9", wifis[9].ssid);
callable("key9", wifis[9].key);
}
template<typename T>
void StringSettings::executeForEveryProfileSetting(T &&callable)
{
}
}

28
main/texts.h
View File

@ -7,10 +7,6 @@ constexpr char TEXT_BACK[] = "Back";
//AccessPointWifiSettingsMenu
constexpr char TEXT_ACCESSPOINTWIFISETTINGS[] = "Access Point WiFi settings";
constexpr char TEXT_WIFISOFTAP[] = "softAP()";
constexpr char TEXT_WIFISOFTAPDISCONNECT[] = "softAPdisconnect()";
constexpr char TEXT_WIFISOFTAPDISCONNECTWIFIOFF[] = "softAPdisconnect() wifioff";
constexpr char TEXT_WIFISOFTAPENABLEIPV6[] = "softAPenableIpV6()";
//constexpr char TEXT_BACK[] = "Back";
#ifdef FEATURE_BLUETOOTH
@ -107,11 +103,8 @@ constexpr char TEXT_CANRECEIVETIMEOUT[] = "CanReceiveTimeout";
//StationWifiSettingsMenu
constexpr char TEXT_STATIONWIFISETTINGS[] = "Station WiFi settings";
constexpr char TEXT_WIFIENABLED[] = "WiFi enabled";
constexpr char TEXT_WIFIRECONNECT[] = "reconnect()";
constexpr char TEXT_WIFIDISCONNECT[] = "disconnect()";
constexpr char TEXT_WIFICHANGEAUTOCONNECT[] = "Change auto connect";
constexpr char TEXT_WIFICHANGEAUTORECONNECT[] = "Change auto reconnect";
constexpr char TEXT_WIFIENABLEIPV6[] = "enableIpV6()";
constexpr char TEXT_WIFITRIGGERSCAN[] = "Trigger Scan";
constexpr char TEXT_WIFISCANRESULTS[] = "WiFi scan results";
//constexpr char TEXT_BACK[] = "Back";
//DemosMenu
@ -183,10 +176,6 @@ constexpr char TEXT_GAMETRAKMODESETTINGS[] = "Gametrak mode settings";
//GenericWifiSettingsMenu
constexpr char TEXT_GENERICWIFISETTINGS[] = "Generic WiFi settings";
constexpr char TEXT_WIFICHANGEMODE[] = "Change mode";
constexpr char TEXT_WIFICHANGESLEEP[] = "Change sleep";
constexpr char TEXT_WIFICHANGETXPOWER[] = "Change tx power";
constexpr char TEXT_WIFISCAN[] = "WiFi scan";
//constexpr char TEXT_BACK[] = "Back";
//GraphsMenu
@ -205,6 +194,7 @@ 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";
//InvertMenu
@ -251,12 +241,12 @@ constexpr char TEXT_NCRUISEMOTTGT[] = "nCruiseMotTgt";
//BoardcomputerHardwareSettingsMenu
//constexpr char TEXT_BOARDCOMPUTERHARDWARESETTINGS[] = "Boardcomputer H/W settings";
constexpr char TEXT_CALIBRATE[] = "Calibrate";
constexpr char TEXT_SETSAMPLECOUNT[] = "Set sampleCount";
constexpr char TEXT_SETGASMIN[] = "Set gasMin";
constexpr char TEXT_SETGASMAX[] = "Set gasMax";
constexpr char TEXT_SETBREMSMIN[] = "Set bremsMin";
constexpr char TEXT_SETBREMSMAX[] = "Set bremsMax";
constexpr char TEXT_SETDPADDEBOUNCE[] = "Set dpadDebounce";
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";

11
main/utils.h
View File

@ -1,15 +1,20 @@
#pragma once
// system includes
#include <algorithm>
#include <utility>
#include <string>
// Arduino includes
#ifdef FEATURE_SERIAL
#include <HardwareSerial.h>
#endif
// 3rdparty lib includes
#include <espchrono.h>
#include <futurecpp.h>
// local includes
#ifdef FEATURE_CAN
#include "bobbycar-can.h"
#endif
@ -102,7 +107,7 @@ std::string to_string(bobbycar::protocol::ControlType value)
case ControlType::Sinusoidal: return "Sinusoidal";
case ControlType::FieldOrientedControl: return "FieldOrientedControl";
}
return "Unknown ControlType(" + std::to_string(int(value)) + ')';
return fmt::format("Unknown ControlType({})", std::to_underlying(value));
}
std::string to_string(bobbycar::protocol::ControlMode value)
@ -115,7 +120,7 @@ std::string to_string(bobbycar::protocol::ControlMode value)
case ControlMode::Speed: return "Speed";
case ControlMode::Torque: return "Torque";
}
return "Unknown ControlMode(" + std::to_string(int(value)) + ')';
return fmt::format("Unknown ControlMode({})", std::to_underlying(value));
}
std::array<std::reference_wrapper<bobbycar::protocol::serial::MotorState>, 2> motorsInController(Controller &controller)
@ -251,11 +256,13 @@ void updateSwapFrontBack()
void loadSettings()
{
settingsPersister.load(settings);
settingsPersister.load(stringSettings);
}
void saveSettings()
{
settingsPersister.save(settings);
settingsPersister.save(stringSettings);
}
void updateAccumulators()

24
main/wifi_bobbycar.h
View File

@ -12,21 +12,21 @@
namespace {
wifi_stack::config wifi_create_config()
{
static wifi_stack::config config {
return wifi_stack::config {
.wifiEnabled = settings.wifiSettings.wifiEnabled,
.hostname = deviceName,
.sta = {
.wifis = std::array<wifi_stack::wifi_entry, 10> {
wifi_stack::wifi_entry { .ssid = "realraum", .key = "r3alraum" },
wifi_stack::wifi_entry { .ssid = "McDonalds Free WiFi", .key = "Passwort_123" },
wifi_stack::wifi_entry { .ssid = {}, .key = {} },
wifi_stack::wifi_entry { .ssid = {}, .key = {} },
wifi_stack::wifi_entry { .ssid = {}, .key = {} },
wifi_stack::wifi_entry { .ssid = {}, .key = {} },
wifi_stack::wifi_entry { .ssid = {}, .key = {} },
wifi_stack::wifi_entry { .ssid = {}, .key = {} },
wifi_stack::wifi_entry { .ssid = {}, .key = {} },
wifi_stack::wifi_entry { .ssid = {}, .key = {} }
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[0].ssid, .key = stringSettings.wifis[0].key },
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[1].ssid, .key = stringSettings.wifis[1].key },
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[2].ssid, .key = stringSettings.wifis[2].key },
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[3].ssid, .key = stringSettings.wifis[3].key },
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[4].ssid, .key = stringSettings.wifis[4].key },
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[5].ssid, .key = stringSettings.wifis[5].key },
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[6].ssid, .key = stringSettings.wifis[6].key },
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[7].ssid, .key = stringSettings.wifis[7].key },
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[8].ssid, .key = stringSettings.wifis[8].key },
wifi_stack::wifi_entry { .ssid = stringSettings.wifis[9].ssid, .key = stringSettings.wifis[9].key }
},
.min_rssi = -90
},
@ -45,8 +45,6 @@ wifi_stack::config wifi_create_config()
.beacon_interval = 100
}
};
return config;
}
void wifi_begin()

245
main/wifitexthelpers.h
View File

@ -1,45 +1,218 @@
#pragma once
// 3rdparty lib includes
#include <fmt/core.h>
#include <espwifistack.h>
#include <esp_netif.h>
#include <lwip/dns.h>
// local includes
#include "textinterface.h"
namespace {
constexpr char TEXT_STATUSBITS[] = "statusBits: ";
using WifiStatusBitsText = StaticText<TEXT_STATUSBITS>; //StatusTextHelper<TEXT_STATUSBITS, &WiFi::getStatusBits>;
constexpr char TEXT_CHANNEL[] = "channel: ";
using WifiChannelText = StaticText<TEXT_CHANNEL>; //StatusTextHelper<TEXT_CHANNEL, &WiFi::channel>;
class WifiStatusText : public virtual TextInterface { public: std::string text() const override {
return fmt::format("Status: {}", wifi_stack::toString(wifi_stack::get_sta_status())); }};
constexpr char TEXT_ISCONNECTED[] = "isConnected: ";
using WifiIsConnectedText = StaticText<TEXT_ISCONNECTED>; //StatusTextHelper<TEXT_ISCONNECTED, &WiFi.isConnected>
constexpr char TEXT_LOCALIP[] = "localIP: ";
using WifiLocalIpText = StaticText<TEXT_LOCALIP>; //StatusTextHelper<TEXT_LOCALIP, &WiFi.localIP>
constexpr char TEXT_MACADDRESS[] = "macAddress: ";
using WifiMacAddressText = StaticText<TEXT_MACADDRESS>; //StatusTextHelper<TEXT_MACADDRESS, &WiFi.macAddress>
constexpr char TEXT_SUBNETMASK[] = "subnetMask: ";
using WifiSubnetMaskText = StaticText<TEXT_SUBNETMASK>; //StatusTextHelper<TEXT_SUBNETMASK, &WiFi.subnetMask>
constexpr char TEXT_GATEWAYIP[] = "gatewayIP: ";
using WifiGatewayIpText = StaticText<TEXT_GATEWAYIP>; //StatusTextHelper<TEXT_GATEWAYIP, &WiFi.gatewayIP>
constexpr char TEXT_DNSIP[] = "dnsIP: ";
using WifiDnsIpText = StaticText<TEXT_DNSIP>; //StatusTextHelper<TEXT_DNSIP, &WiFi.dnsIP>
constexpr char TEXT_BROADCASTIP[] = "broadcastIP: ";
using WifiBroadcastIpText = StaticText<TEXT_BROADCASTIP>; //StatusTextHelper<TEXT_BROADCASTIP, &WiFi.broadcastIP>
constexpr char TEXT_NETWORKID[] = "networkID: ";
using WifiNetworkIdText = StaticText<TEXT_NETWORKID>; //StatusTextHelper<TEXT_NETWORKID, &WiFi.networkID>
constexpr char TEXT_SUBNETCIDR[] = "subnetCIDR: ";
using WifiSubnetCIDRText = StaticText<TEXT_SUBNETCIDR>; //StatusTextHelper<TEXT_SUBNETCIDR, &WiFi.subnetCIDR>
constexpr char TEXT_LOCALIPV6[] = "localIPv6: ";
using WifiLocalIpV6Text = StaticText<TEXT_LOCALIPV6>; //StatusTextHelper<TEXT_LOCALIPV6, &WiFi.localIPv6>
constexpr char TEXT_HOSTNAME[] = "hostname: ";
using WifiHostnameText = StaticText<TEXT_HOSTNAME>; //StatusTextHelper<TEXT_HOSTNAME, &WiFi.getHostname>
constexpr char TEXT_STATUS2[] = "status: ";
using WifiStatusText = StaticText<TEXT_STATUS2>; //StatusTextHelper<TEXT_STATUS2, &WiFi.status>
constexpr char TEXT_SSID[] = "SSID: ";
using WifiSsidText = StaticText<TEXT_SSID>; //StatusTextHelper<TEXT_SSID, &WiFi.SSID>
constexpr char TEXT_PSK[] = "psk: ";
using WifiPskText = StaticText<TEXT_PSK>; //StatusTextHelper<TEXT_PSK, &WiFi.psk>
constexpr char TEXT_BSSID[] = "BSSID: ";
using WifiBssidText = StaticText<TEXT_BSSID>; //StatusTextHelper<TEXT_BSSID, &WiFi.BSSIDstr>
constexpr char TEXT_RSSI[] = "RSSI: ";
using WifiRssiText = StaticText<TEXT_RSSI>; //StatusTextHelper<TEXT_RSSI, &WiFi.RSSI>
class WifiScanStatusText : public virtual TextInterface { public: std::string text() const override {
return fmt::format("ScanStatus: {}", wifi_stack::toString(wifi_stack::get_scan_status())); }};
class WifiHostnameText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "Hostname: ";
const char *hostname{};
if (const auto result = esp_netif_get_hostname(wifi_stack::esp_netifs[ESP_IF_WIFI_STA], &hostname); result == ESP_OK)
if (hostname)
text += hostname;
return text;
}
};
class WifiMacText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "MAC: ";
if (const auto result = wifi_stack::get_base_mac_addr())
text += wifi_stack::toString(*result);
return text;
}
};
class WifiSsidText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "SSID: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += std::string_view{reinterpret_cast<const char*>(result->ssid)};
return text;
}
};
class WifiBssidText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "BSSID: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(wifi_stack::mac_t{result->bssid});
return text;
}
};
class WifiRssiText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "RSSI: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += fmt::format("{}dB", result->rssi);
return text;
}
};
class WifiEncryptionTypeText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "encryptionType: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(result->authmode);
return text;
}
};
class WifiPairwiseCipherText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "pairwiseCipher: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(result->pairwise_cipher);
return text;
}
};
class WifiGroupCipherText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "groupCipher: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(result->group_cipher);
return text;
}
};
class WifiIpText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "ip: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
text += wifi_stack::toString(result->ip);
return text;
}
};
class WifiNetmaskText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "netmask: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
text += wifi_stack::toString(result->netmask);
return text;
}
};
class WifiGatewayText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "gateway: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
text += wifi_stack::toString(result->gw);
return text;
}
};
class WifiIpv6LinklocalText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "ipv6: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
{
esp_ip6_addr_t addr;
if (const auto result = esp_netif_get_ip6_linklocal(wifi_stack::esp_netifs[ESP_IF_WIFI_STA], &addr); result == ESP_OK)
text += wifi_stack::toString(addr);
}
return text;
}
};
class WifiIpv6GlobalText : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "ipv6: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
{
esp_ip6_addr_t addr;
if (const auto result = esp_netif_get_ip6_global(wifi_stack::esp_netifs[ESP_IF_WIFI_STA], &addr); result == ESP_OK)
text += wifi_stack::toString(addr);
}
return text;
}
};
class WifiDns0Text : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "dns0: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const ip_addr_t *dns_ip = dns_getserver(0))
text += wifi_stack::toString(*dns_ip);
return text;
}
};
class WifiDns1Text : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "dns1: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const ip_addr_t *dns_ip = dns_getserver(1))
text += wifi_stack::toString(*dns_ip);
return text;
}
};
class WifiDns2Text : public virtual TextInterface {
public:
std::string text() const override
{
std::string text = "dns2: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::WL_CONNECTED)
if (const ip_addr_t *dns_ip = dns_getserver(2))
text += wifi_stack::toString(*dns_ip);
return text;
}
};
constexpr char TEXT_SOFTAPGETSTATIONNUM[] = "softAPgetStationNum: ";
using WifiSoftApGetStationNumText = StaticText<TEXT_SOFTAPGETSTATIONNUM>; //StatusTextHelper<TEXT_SOFTAPGETSTATIONNUM, &WiFi.softAPgetStationNum>

6
sdkconfig_comred
View File

@ -485,8 +485,8 @@ CONFIG_ADC_CAL_LUT_ENABLE=y
CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE=32
CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=2304
CONFIG_ESP_MAIN_TASK_STACK_SIZE=3584
CONFIG_ESP_MAIN_TASK_CORE_AFFINITY=0
CONFIG_ESP_MAIN_TASK_STACK_SIZE=4096
CONFIG_ESP_MAIN_TASK_CORE_AFFINITY=1
CONFIG_ESP_IPC_TASK_STACK_SIZE=1024
CONFIG_ESP_IPC_USES_CALLERS_PRIORITY=y
CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE=2048
@ -1380,7 +1380,7 @@ CONFIG_ESP32_RTC_CLOCK_SOURCE_INTERNAL_RC=y
# CONFIG_COMPATIBLE_PRE_V2_1_BOOTLOADERS is not set
CONFIG_SYSTEM_EVENT_QUEUE_SIZE=32
CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE=2304
CONFIG_MAIN_TASK_STACK_SIZE=3584
CONFIG_MAIN_TASK_STACK_SIZE=4096
CONFIG_IPC_TASK_STACK_SIZE=1024
CONFIG_CONSOLE_UART_DEFAULT=y
# CONFIG_CONSOLE_UART_CUSTOM is not set

6
sdkconfig_feedc0de
View File

@ -485,8 +485,8 @@ CONFIG_ADC_CAL_LUT_ENABLE=y
CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE=32
CONFIG_ESP_SYSTEM_EVENT_TASK_STACK_SIZE=2304
CONFIG_ESP_MAIN_TASK_STACK_SIZE=3584
CONFIG_ESP_MAIN_TASK_CORE_AFFINITY=0
CONFIG_ESP_MAIN_TASK_STACK_SIZE=4096
CONFIG_ESP_MAIN_TASK_CORE_AFFINITY=1
CONFIG_ESP_IPC_TASK_STACK_SIZE=1024
CONFIG_ESP_IPC_USES_CALLERS_PRIORITY=y
CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE=2048
@ -1382,7 +1382,7 @@ CONFIG_ESP32_RTC_CLOCK_SOURCE_INTERNAL_RC=y
# CONFIG_COMPATIBLE_PRE_V2_1_BOOTLOADERS is not set
CONFIG_SYSTEM_EVENT_QUEUE_SIZE=32
CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE=2304
CONFIG_MAIN_TASK_STACK_SIZE=3584
CONFIG_MAIN_TASK_STACK_SIZE=4096
CONFIG_IPC_TASK_STACK_SIZE=1024
CONFIG_CONSOLE_UART_DEFAULT=y
# CONFIG_CONSOLE_UART_CUSTOM is not set