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

Add new WiFi menu

Browse Source
This commit is contained in:
0xFEEDC0DE64
2021-12-29 02:13:10 +01:00
parent 86e5e9cf0e
commit 3f6eeca8d6
53 changed files with 1760 additions and 673 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
main/CMakeLists.txt
View File

@ -71,7 +71,6 @@ set(headers
displays/lockscreen.h
displays/menudisplaywithtime.cpp
displays/menus/aboutmenu.h
displays/menus/accesspointwifisettingsmenu.h
displays/menus/batterydebugmenu.h
displays/menus/batterymenu.h
displays/menus/blesettingsmenu.h
@ -93,7 +92,6 @@ set(headers
displays/menus/feedbackdebugmenu.h
displays/menus/garagenmenu.h
displays/menus/gametrakmodesettingsmenu.h
displays/menus/genericwifisettingsmenu.h
displays/menus/graphsmenu.h
displays/menus/greenpassmenu.h
displays/menus/handbremssettingsmenu.h
@ -111,6 +109,7 @@ set(headers
displays/menus/motorfeedbackdebugmenu.h
displays/menus/motorstatedebugmenu.h
displays/menus/motortestmodesettingsmenu.h
displays/menus/networksettingsmenu.h
displays/menus/otamenu.h
displays/menus/presetsmenu.h
displays/menus/profilesmenu.h
@ -120,15 +119,14 @@ set(headers
displays/menus/selectmodemenu.h
displays/menus/selectotabuildmenu.h
displays/menus/settingsmenu.h
displays/menus/stationwifisettingsmenu.h
displays/menus/statisticsmenu.h
displays/menus/taskmanagermenu.h
displays/menus/tempomatmodesettingsmenu.h
displays/menus/timersmenu.h
displays/menus/timesettingsmenu.h
displays/menus/udpcloudsettingsmenu.h
displays/menus/wifiscanmenu.h
displays/menus/wifisettingsmenu.h
displays/menus/wifistasettingsmenu.h
displays/menus/wifiapsettingsmenu.h
displays/metersdisplay.h
displays/pingpongdisplay.h
displays/popups/alertdisplay.h
@ -222,7 +220,20 @@ set(headers
widgets/doubleprogressbar.h
displays/menudisplaywithtime.h
wifi_bobbycar.h
wifitexthelpers.h
texthelpers/networktexthelpers.h
texthelpers/wifistatexthelpers.h
wifiguiutils.h
accessors/wifistaconfigaccessors.h
displays/menus/wifistascanmenu.h
displays/menus/wifistaconfigsmenu.h
displays/menus/wifistascanentrymenu.h
displays/menus/wifiapclientsmenu.h
displays/menus/wifistaconfigentrymenu.h
texthelpers/wifistaconfigtexthelpers.h
accessors/wifiapconfigaccessors.h
texthelpers/wifiaptexthelpers.h
actions/wifistascanaction.h
actions/wifistascanclearaction.h
)
set(sources
@ -297,7 +308,6 @@ set(sources
displays/ledstripcolorsdisplay.cpp
displays/lockscreen.cpp
displays/menus/aboutmenu.cpp
displays/menus/accesspointwifisettingsmenu.cpp
displays/menus/batterydebugmenu.cpp
displays/menus/batterymenu.cpp
displays/menus/blesettingsmenu.cpp
@ -319,7 +329,6 @@ set(sources
displays/menus/feedbackdebugmenu.cpp
displays/menus/garagenmenu.cpp
displays/menus/gametrakmodesettingsmenu.cpp
displays/menus/genericwifisettingsmenu.cpp
displays/menus/graphsmenu.cpp
displays/menus/greenpassmenu.cpp
displays/menus/handbremssettingsmenu.cpp
@ -337,6 +346,7 @@ set(sources
displays/menus/motorfeedbackdebugmenu.cpp
displays/menus/motorstatedebugmenu.cpp
displays/menus/motortestmodesettingsmenu.cpp
displays/menus/networksettingsmenu.cpp
displays/menus/otamenu.cpp
displays/menus/presetsmenu.cpp
displays/menus/profilesmenu.cpp
@ -346,15 +356,14 @@ set(sources
displays/menus/selectmodemenu.cpp
displays/menus/selectotabuildmenu.cpp
displays/menus/settingsmenu.cpp
displays/menus/stationwifisettingsmenu.cpp
displays/menus/statisticsmenu.cpp
displays/menus/taskmanagermenu.cpp
displays/menus/tempomatmodesettingsmenu.cpp
displays/menus/timersmenu.cpp
displays/menus/timesettingsmenu.cpp
displays/menus/udpcloudsettingsmenu.cpp
displays/menus/wifiscanmenu.cpp
displays/menus/wifisettingsmenu.cpp
displays/menus/wifistasettingsmenu.cpp
displays/menus/wifiapsettingsmenu.cpp
displays/metersdisplay.cpp
displays/pingpongdisplay.cpp
displays/popups/alertdisplay.cpp
@ -448,7 +457,20 @@ set(sources
webserver_newsettings.cpp
widgets/doubleprogressbar.cpp
wifi_bobbycar.cpp
wifitexthelpers.cpp
texthelpers/networktexthelpers.cpp
texthelpers/wifistatexthelpers.cpp
wifiguiutils.cpp
accessors/wifistaconfigaccessors.cpp
displays/menus/wifistascanmenu.cpp
displays/menus/wifistaconfigsmenu.cpp
displays/menus/wifistascanentrymenu.cpp
displays/menus/wifiapclientsmenu.cpp
displays/menus/wifistaconfigentrymenu.cpp
texthelpers/wifistaconfigtexthelpers.cpp
accessors/wifiapconfigaccessors.cpp
texthelpers/wifiaptexthelpers.cpp
actions/wifistascanaction.cpp
actions/wifistascanclearaction.cpp
)
set(dependencies

12
main/accessors/wifiapconfigaccessors.cpp Normal file
View File

@ -0,0 +1,12 @@
#include "wifiapconfigaccessors.h"
// local includes
#include "newsettings.h"
using namespace espgui;
bool WifiApEnabledAccessor::getValue() const { return configs.wifiApEnabled.value; }
void WifiApEnabledAccessor::setValue(bool value) { configs.write_config(configs.wifiApEnabled, value); }
//bool WifiApDisableWhenOnlineAccessor::getValue() const { return configs.wifiDisableApWhenOnline.value; }
//void WifiApDisableWhenOnlineAccessor::setValue(bool value) { configs.write_config(configs.wifiDisableApWhenOnline, value); }

22
main/accessors/wifiapconfigaccessors.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
// system includes
#include <string>
// 3rdparty lib includes
#include <accessorinterface.h>
#include <espwifiutils.h>
class WifiApEnabledAccessor : public virtual espgui::AccessorInterface<bool>
{
public:
bool getValue() const override;
void setValue(bool value) override;
};
//class WifiApDisableWhenOnlineAccessor : public virtual espgui::AccessorInterface<bool>
//{
//public:
// bool getValue() const override;
// void setValue(bool value) override;
//};

39
main/accessors/wifistaconfigaccessors.cpp Normal file
View File

@ -0,0 +1,39 @@
#include "wifistaconfigaccessors.h"
// local includes
#include "newsettings.h"
using namespace espgui;
bool WifiStaEnabledAccessor::getValue() const { return configs.wifiStaEnabled.value; }
void WifiStaEnabledAccessor::setValue(bool value) { configs.write_config(configs.wifiStaEnabled, value); }
std::string WifiStaConfigSsidAccessor::getValue() const { return configs.wifi_configs[m_index].ssid.value; }
void WifiStaConfigSsidAccessor::setValue(std::string value) { configs.write_config(configs.wifi_configs[m_index].ssid, value); }
std::string WifiStaConfigKeyAccessor::getValue() const { return configs.wifi_configs[m_index].key.value; }
void WifiStaConfigKeyAccessor::setValue(std::string value) { configs.write_config(configs.wifi_configs[m_index].key, value); }
bool WifiStaConfigUseStaticIpAccessor::getValue() const { return configs.wifi_configs[m_index].useStaticIp.value; }
void WifiStaConfigUseStaticIpAccessor::setValue(bool value) { configs.write_config(configs.wifi_configs[m_index].useStaticIp, value); }
wifi_stack::ip_address_t WifiStaConfigStaticIpAccessor::getValue() const { return configs.wifi_configs[m_index].staticIp.value; }
void WifiStaConfigStaticIpAccessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticIp, value); }
wifi_stack::ip_address_t WifiStaConfigStaticSubnetAccessor::getValue() const { return configs.wifi_configs[m_index].staticSubnet.value; }
void WifiStaConfigStaticSubnetAccessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticSubnet, value); }
wifi_stack::ip_address_t WifiStaConfigStaticGatewayAccessor::getValue() const { return configs.wifi_configs[m_index].staticGateway.value; }
void WifiStaConfigStaticGatewayAccessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticGateway, value); }
bool WifiStaConfigUseStaticDnsAccessor::getValue() const { return configs.wifi_configs[m_index].useStaticDns.value; }
void WifiStaConfigUseStaticDnsAccessor::setValue(bool value) { configs.write_config(configs.wifi_configs[m_index].useStaticDns, value); }
wifi_stack::ip_address_t WifiStaConfigStaticDns0Accessor::getValue() const { return configs.wifi_configs[m_index].staticDns0.value; }
void WifiStaConfigStaticDns0Accessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticDns0, value); }
wifi_stack::ip_address_t WifiStaConfigStaticDns1Accessor::getValue() const { return configs.wifi_configs[m_index].staticDns1.value; }
void WifiStaConfigStaticDns1Accessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticDns1, value); }
wifi_stack::ip_address_t WifiStaConfigStaticDns2Accessor::getValue() const { return configs.wifi_configs[m_index].staticDns2.value; }
void WifiStaConfigStaticDns2Accessor::setValue(wifi_stack::ip_address_t value) { configs.write_config(configs.wifi_configs[m_index].staticDns2, value); }

137
main/accessors/wifistaconfigaccessors.h Normal file
View File

@ -0,0 +1,137 @@
#pragma once
#include "sdkconfig.h"
// system includes
#include <string>
// 3rdparty lib includes
#include <accessorinterface.h>
#include <espwifiutils.h>
class WifiStaEnabledAccessor : public virtual espgui::AccessorInterface<bool>
{
public:
bool getValue() const override;
void setValue(bool value) override;
};
class WifiStaConfigSsidAccessor : public virtual espgui::AccessorInterface<std::string>
{
public:
WifiStaConfigSsidAccessor(int index) : m_index{index} {}
std::string getValue() const override;
void setValue(std::string value) override;
private:
const int m_index;
};
class WifiStaConfigKeyAccessor : public virtual espgui::AccessorInterface<std::string>
{
public:
WifiStaConfigKeyAccessor(int index) : m_index{index} {}
std::string getValue() const override;
void setValue(std::string value) override;
private:
const int m_index;
};
class WifiStaConfigUseStaticIpAccessor : public virtual espgui::AccessorInterface<bool>
{
public:
WifiStaConfigUseStaticIpAccessor(int index) : m_index{index} {}
bool getValue() const override;
void setValue(bool value) override;
private:
const int m_index;
};
class WifiStaConfigStaticIpAccessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
{
public:
WifiStaConfigStaticIpAccessor(int index) : m_index{index} {}
wifi_stack::ip_address_t getValue() const override;
void setValue(wifi_stack::ip_address_t value) override;
private:
const int m_index;
};
class WifiStaConfigStaticSubnetAccessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
{
public:
WifiStaConfigStaticSubnetAccessor(int index) : m_index{index} {}
wifi_stack::ip_address_t getValue() const override;
void setValue(wifi_stack::ip_address_t value) override;
private:
const int m_index;
};
class WifiStaConfigStaticGatewayAccessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
{
public:
WifiStaConfigStaticGatewayAccessor(int index) : m_index{index} {}
wifi_stack::ip_address_t getValue() const override;
void setValue(wifi_stack::ip_address_t value) override;
private:
const int m_index;
};
class WifiStaConfigUseStaticDnsAccessor : public virtual espgui::AccessorInterface<bool>
{
public:
WifiStaConfigUseStaticDnsAccessor(int index) : m_index{index} {}
bool getValue() const override;
void setValue(bool value) override;
private:
const int m_index;
};
class WifiStaConfigStaticDns0Accessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
{
public:
WifiStaConfigStaticDns0Accessor(int index) : m_index{index} {}
wifi_stack::ip_address_t getValue() const override;
void setValue(wifi_stack::ip_address_t value) override;
private:
const int m_index;
};
class WifiStaConfigStaticDns1Accessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
{
public:
WifiStaConfigStaticDns1Accessor(int index) : m_index{index} {}
wifi_stack::ip_address_t getValue() const override;
void setValue(wifi_stack::ip_address_t value) override;
private:
const int m_index;
};
class WifiStaConfigStaticDns2Accessor : public virtual espgui::AccessorInterface<wifi_stack::ip_address_t>
{
public:
WifiStaConfigStaticDns2Accessor(int index) : m_index{index} {}
wifi_stack::ip_address_t getValue() const override;
void setValue(wifi_stack::ip_address_t value) override;
private:
const int m_index;
};

20
main/actions/wifistascanaction.cpp Normal file
View File

@ -0,0 +1,20 @@
#include "wifistascanaction.h"
// esp-idf includes
#include <esp_log.h>
// local includes
#include "wifi_bobbycar.h"
namespace {
constexpr const char * const TAG = "BOBBY";
} // namespace
void WifiStaScanAction::triggered()
{
if (const auto result = wifi_scan(); result != ESP_OK)
{
ESP_LOGE(TAG, "wifi_scan() failed: %s", esp_err_to_name(result));
return;
}
}

10
main/actions/wifistascanaction.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
// 3rdparty lib includes
#include <actioninterface.h>
class WifiStaScanAction : public virtual espgui::ActionInterface
{
public:
void triggered() override;
};

9
main/actions/wifistascanclearaction.cpp Normal file
View File

@ -0,0 +1,9 @@
#include "wifistascanclearaction.h"
// 3rdparty lib includes
#include <espwifistack.h>
void WifiStaScanClearAction::triggered()
{
wifi_stack::delete_scan_result();
}

10
main/actions/wifistascanclearaction.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
// 3rdparty lib includes
#include <actioninterface.h>
class WifiStaScanClearAction : public virtual espgui::ActionInterface
{
public:
void triggered() override;
};

33
main/displays/menus/accesspointwifisettingsmenu.cpp
View File

@ -1,33 +0,0 @@
#include "accesspointwifisettingsmenu.h"
// local includes
#include "accessors/settingsaccessors.h"
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "displays/menus/wifisettingsmenu.h"
#include "icons/back.h"
#include "menuitem.h"
#include "wifitexthelpers.h"
using namespace espgui;
AccessPointWifiSettingsMenu::AccessPointWifiSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFIAPENABLED>, ToggleBoolAction, CheckboxIcon, WifiApEnabledAccessor>>();
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, WifiSoftApIpV6Text, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApHostnameText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiSoftApMacAddressText, StaticFont<2>, DisabledColor, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void AccessPointWifiSettingsMenu::back()
{
switchScreen<WifiSettingsMenu>();
}

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

@ -1,14 +0,0 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class AccessPointWifiSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_ACCESSPOINTWIFISETTINGS>
{
public:
AccessPointWifiSettingsMenu();
void back() override;
};

0
main/displays/menus/genericwifisettingsmenu.cpp
View File

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

@ -1,30 +0,0 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
#include "changevaluedisplay.h"
#include "menuitem.h"
#include "actions/dummyaction.h"
#include "actions/toggleboolaction.h"
#include "actions/switchscreenaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
#include "wifitexthelpers.h"
#include "accessors/wifiaccessors.h"
#include "texts.h"
using namespace espgui;
namespace {
class GenericWifiSettingsMenu :
public BobbyMenuDisplay,
public StaticText<TEXT_GENERICWIFISETTINGS>,
public BackActionInterface<SwitchScreenAction<WifiSettingsMenu>>
{
public:
GenericWifiSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
};
} // namespace

45
main/displays/menus/networksettingsmenu.cpp Normal file
View File

@ -0,0 +1,45 @@
#include "networksettingsmenu.h"
// 3rdparty lib includes
#include <menuitem.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <fmt/format.h>
// local includes
#include "wifistasettingsmenu.h"
#include "wifiapsettingsmenu.h"
#include "settingsmenu.h"
#include "texthelpers/networktexthelpers.h"
using namespace espgui;
namespace {
constexpr char TEXT_STASETTINGS[] = "STA Settings";
constexpr char TEXT_APSETTINGS[] = "AP Settings";
//constexpr char TEXT_BACK[] = "Back";
} // namespace
NetworkSettingsMenu::NetworkSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STASETTINGS>, SwitchScreenAction<WifiStaSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_APSETTINGS>, SwitchScreenAction<WifiApSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, WifiDefaultMacText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiBaseMacText, DummyAction>>();
constructMenuItem<makeComponentArgs<MenuItem, DnsText, DummyAction>>(uint8_t{0});
constructMenuItem<makeComponentArgs<MenuItem, DnsText, DummyAction>>(uint8_t{1});
constructMenuItem<makeComponentArgs<MenuItem, DnsText, DummyAction>>(uint8_t{2});
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
std::string NetworkSettingsMenu::text() const
{
return "Network settings";
}
void NetworkSettingsMenu::back()
{
switchScreen<SettingsMenu>();
}

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

@ -0,0 +1,13 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
class NetworkSettingsMenu : public BobbyMenuDisplay
{
public:
NetworkSettingsMenu();
std::string text() const override;
void back() override;
};

4
main/displays/menus/settingsmenu.cpp
View File

@ -24,7 +24,7 @@
#include "globals.h"
#include "accessors/settingsaccessors.h"
#include "displays/menus/limitssettingsmenu.h"
#include "displays/menus/wifisettingsmenu.h"
#include "displays/menus/networksettingsmenu.h"
#include "displays/menus/bluetoothsettingsmenu.h"
#include "displays/menus/blesettingsmenu.h"
#ifdef FEATURE_CLOUD
@ -66,7 +66,7 @@ SettingsMenu::SettingsMenu()
if (!simplified)
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_LIMITSSETTINGS>, SwitchScreenAction<LimitsSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISETTINGS>, SwitchScreenAction<WifiSettingsMenu>, StaticMenuItemIcon<&bobbyicons::wifi>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_NETWORKSETTINGS>, SwitchScreenAction<NetworkSettingsMenu>, StaticMenuItemIcon<&bobbyicons::wifi>>>();
#ifdef FEATURE_ESPNOW
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ESPNOW>, SwitchScreenAction<EspNowMenu>, StaticMenuItemIcon<&bobbyicons::wifi>>>();
#endif

52
main/displays/menus/stationwifisettingsmenu.cpp
View File

@ -1,52 +0,0 @@
#include "stationwifisettingsmenu.h"
// 3rdparty lib includes
#include "menuitem.h"
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
#include "actions/toggleboolaction.h"
#include "checkboxicon.h"
#include "icons/back.h"
// local includes
#include "utils.h"
#include "actions/wifiscanaction.h"
#include "icons/scan.h"
#include "wifitexthelpers.h"
#include "accessors/wifiaccessors.h"
#include "accessors/settingsaccessors.h"
#include "displays/menus/wifiscanmenu.h"
#include "displays/menus/wifisettingsmenu.h"
using namespace espgui;
StationWifiSettingsMenu::StationWifiSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISTAENABLED>, ToggleBoolAction, CheckboxIcon, WifiStaEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFITRIGGERSCAN>, WifiScanAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_WIFISCANRESULTS>, SwitchScreenAction<WifiScanMenu>, StaticMenuItemIcon<&bobbyicons::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<&espgui::icons::back>>>();
}
void StationWifiSettingsMenu::back()
{
switchScreen<WifiSettingsMenu>();
}

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

@ -1,15 +0,0 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class StationWifiSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_STATIONWIFISETTINGS>
{
public:
StationWifiSettingsMenu();
void back() override;
};

153
main/displays/menus/wifiapclientsmenu.cpp Normal file
View File

@ -0,0 +1,153 @@
#include "wifiapclientsmenu.h"
// esp-idf includes
#include <esp_log.h>
#include <esp_wifi.h>
#include <dhcpserver/dhcpserver.h>
// 3rdparty lib includes
#include <menuitem.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <fmt/format.h>
#include <espwifiutils.h>
// local includes
#include "wifiapsettingsmenu.h"
#include "wifiguiutils.h"
using namespace std::chrono_literals;
using namespace std::string_literals;
using namespace espgui;
namespace {
constexpr const char * const TAG = "GOE";
constexpr char TEXT_BACK[] = "Back";
class WifiApClientMenuItem : public MenuItem
{
public:
WifiApClientMenuItem(const wifi_sta_info_t &info) : m_info{info} { updateIp(); }
void setInfo(const wifi_sta_info_t &info) { m_info = info; updateIp(); }
void triggered() override;
std::string text() const override;
private:
void updateIp();
private:
wifi_sta_info_t m_info;
ip4_addr_t m_ip;
};
} // namespace
WifiApClientsMenu::WifiApClientsMenu() :
espgui::ChangeableText{"AP Clients"s}
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiApSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
void WifiApClientsMenu::back()
{
switchScreen<WifiApSettingsMenu>();
}
void WifiApClientsMenu::start()
{
Base::start();
m_lastSync = espchrono::millis_clock::now();
doSyncItems();
}
void WifiApClientsMenu::update()
{
const auto now = espchrono::millis_clock::now();
if (now - m_lastSync >= 100ms)
{
m_lastSync = now;
doSyncItems();
}
Base::update();
}
void WifiApClientsMenu::doSyncItems()
{
wifi_sta_list_t clients;
if (const auto result = esp_wifi_ap_get_sta_list(&clients); result != ESP_OK)
{
ESP_LOGE(TAG, "esp_wifi_ap_get_sta_list() failed with %s", esp_err_to_name(result));
setTitle(fmt::format("AP Clients (&1{}&c)", esp_err_to_name(result)));
clients.num = 0;
}
else
setTitle(fmt::format("AP Clients ({})", clients.num));
auto backButton = takeLastMenuItem();
for (std::size_t i = 0; i < clients.num; i++)
{
if (menuItemCount() <= i)
constructMenuItem<WifiApClientMenuItem>(clients.sta[i]);
else
((WifiApClientMenuItem*)(&getMenuItem(i)))->setInfo(clients.sta[i]);
}
while (menuItemCount() > clients.num)
takeLastMenuItem();
emplaceMenuItem(std::move(backButton));
}
namespace {
void WifiApClientMenuItem::triggered()
{
uint16_t aid{};
if (const auto result = esp_wifi_ap_get_sta_aid(m_info.mac, &aid); result != ESP_OK)
{
ESP_LOGE(TAG, "esp_wifi_ap_get_sta_aid() failed with %s", esp_err_to_name(result));
return;
}
if (!aid)
{
ESP_LOGE(TAG, "aid is invalid");
return;
}
if (const auto result = esp_wifi_deauth_sta(aid); result != ESP_OK)
{
ESP_LOGE(TAG, "esp_wifi_deauth_sta() failed with %s", esp_err_to_name(result));
return;
}
}
std::string WifiApClientMenuItem::text() const
{
return fmt::format("{}{}&c {}",
rssiToColor(m_info.rssi),
m_info.rssi,
(std::chrono::milliseconds{espchrono::millis_clock::now().time_since_epoch()} % 4000ms) < 2000ms ?
wifi_stack::toString(wifi_stack::mac_t{m_info.mac}) :
wifi_stack::toString(m_ip)
);
}
void WifiApClientMenuItem::updateIp()
{
if (!dhcp_search_ip_on_mac(m_info.mac, &m_ip))
{
ESP_LOGE(TAG, "dhcp_search_ip_on_mac() failed");
m_ip = { .addr = {} };
return;
}
}
} // namespace

28
main/displays/menus/wifiapclientsmenu.h Normal file
View File

@ -0,0 +1,28 @@
#pragma once
// 3rdparty lib includes
#include <espchrono.h>
// local includes
#include "displays/bobbymenudisplay.h"
class WifiApClientsMenu :
public BobbyMenuDisplay,
public virtual espgui::ChangeableText
{
using Base = BobbyMenuDisplay;
public:
WifiApClientsMenu();
void back() override;
void start() override;
void update() override;
private:
void doSyncItems();
private:
espchrono::millis_clock::time_point m_lastSync;
};

71
main/displays/menus/wifiapsettingsmenu.cpp Normal file
View File

@ -0,0 +1,71 @@
#include "wifiapsettingsmenu.h"
// esp-idf includes
#include <esp_log.h>
// 3rdparty lib includes
#include <menuitem.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <checkboxicon.h>
#include <actions/toggleboolaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <espwifistack.h>
// local includes
#include "wifiapclientsmenu.h"
#include "networksettingsmenu.h"
#include "accessors/wifiapconfigaccessors.h"
#include "texthelpers/wifiaptexthelpers.h"
using namespace espgui;
namespace {
constexpr const char * const TAG = "GOE";
constexpr char TEXT_ENABLED[] = "Enabled";
constexpr char TEXT_DISABLEWHENONLINE[] = "Disable when online";
constexpr char TEXT_BACK[] = "Back";
class WifiApClientsAction : public virtual ActionInterface
{
public:
void triggered() override;
};
} // namespace
WifiApSettingsMenu::WifiApSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, WifiApNameText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiApKeyText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiApMacText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiApIpText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiApMaskText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiApHostnameText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLED>, ToggleBoolAction, CheckboxIcon, WifiApEnabledAccessor>>();
//constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_DISABLEWHENONLINE>, ToggleBoolAction, CheckboxIcon, WifiApDisableWhenOnlineAccessor>>();
constructMenuItem<makeComponent<MenuItem, WifiApClientsText, WifiApClientsAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<NetworkSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
std::string WifiApSettingsMenu::text() const
{
return "AP Settings";
}
void WifiApSettingsMenu::back()
{
switchScreen<NetworkSettingsMenu>();
}
namespace {
void WifiApClientsAction::triggered()
{
wifi_sta_list_t clients;
if (const auto result = esp_wifi_ap_get_sta_list(&clients); result == ESP_OK)
switchScreen<WifiApClientsMenu>();
else
ESP_LOGW(TAG, "esp_wifi_ap_get_sta_list() failed with %s", esp_err_to_name(result));
}
} // namespace

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

@ -0,0 +1,13 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
class WifiApSettingsMenu : public BobbyMenuDisplay
{
public:
WifiApSettingsMenu();
std::string text() const override;
void back() override;
};

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

@ -1,125 +0,0 @@
#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<menu_item_t>();
item.setTitle(std::move(ssid));
}
else
{
std::unique_ptr<menu_item_t> ptr = std::move(m_reusableItems.back());
m_reusableItems.pop_back();
ptr->setTitle(std::move(ssid));
emplaceMenuItem(std::move(ptr));
}
}
else
{
auto &item = *(menu_item_t*)(&getMenuItem(i));
item.setTitle(std::move(ssid));
}
}
while (menuItemCount() > (result ? result->entries.size() : 0))
m_reusableItems.emplace_back((menu_item_t*)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()
{
Base::stop();
wifi_stack::delete_scan_result();
}
void WifiScanMenu::back()
{
switchScreen<StationWifiSettingsMenu>();
}

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

@ -1,34 +0,0 @@
#pragma once
// 3rdparty lib includes
#include "actions/dummyaction.h"
#include "actions/switchscreenaction.h"
// local includes
#include "displays/bobbymenudisplay.h"
#include "displays/menus/stationwifisettingsmenu.h"
#include "texts.h"
#include "utils.h"
class WifiScanMenu :
public BobbyMenuDisplay,
public espgui::BackActionInterface<espgui::SwitchScreenAction<StationWifiSettingsMenu>>
{
using Base = BobbyMenuDisplay;
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;
using menu_item_t = espgui::makeComponent<espgui::MenuItem, espgui::ChangeableText, espgui::DummyAction>;
std::vector<std::unique_ptr<menu_item_t>> m_reusableItems;
};

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

@ -1,39 +0,0 @@
#include "wifisettingsmenu.h"
// 3rdparty lib includes
#include "actions/switchscreenaction.h"
#include "icons/back.h"
// local includes
#include "utils.h"
#include "displays/menus/genericwifisettingsmenu.h"
#include "displays/menus/stationwifisettingsmenu.h"
#include "displays/menus/accesspointwifisettingsmenu.h"
#include "displays/menus/settingsmenu.h"
#include "globals.h"
using namespace espgui;
#ifdef FEATURE_DNS_NS
class ResendDNSRequest : public virtual ActionInterface
{
public:
void triggered() override { dns_lastIpAddress_v4 = "---"; dns_lastIpAddress_v6 = "---"; dns_lastIpAddress_v6_global = "---"; }
};
#endif
WifiSettingsMenu::WifiSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_GENERICWIFISETTINGS>, SwitchScreenAction<GenericWifiSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STATIONWIFISETTINGS>, SwitchScreenAction<StationWifiSettingsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ACCESSPOINTWIFISETTINGS>, SwitchScreenAction<AccessPointWifiSettingsMenu>>>();
#ifdef FEATURE_DNS_NS
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_RESEND_DNS>, ResendDNSRequest>>();
#endif
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<SettingsMenu>, StaticMenuItemIcon<&espgui::icons::back>>>();
}
void WifiSettingsMenu::back()
{
switchScreen<SettingsMenu>();
}

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

@ -1,15 +0,0 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
#include "texts.h"
class WifiSettingsMenu :
public BobbyMenuDisplay,
public espgui::StaticText<TEXT_WIFISETTINGS>
{
public:
WifiSettingsMenu();
void back() override;
};

49
main/displays/menus/wifistaconfigentrymenu.cpp Normal file
View File

@ -0,0 +1,49 @@
#include "wifistaconfigentrymenu.h"
// 3rdparty lib includes
#include <menuitem.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <actions/toggleboolaction.h>
#include <checkboxicon.h>
// local includes
#include "texthelpers/wifistaconfigtexthelpers.h"
#include "accessors/wifistaconfigaccessors.h"
#include "wifistaconfigsmenu.h"
using namespace espgui;
namespace {
constexpr char TEXT_USESTATICIP[] = "Use Static Ip";
constexpr char TEXT_USESTATICDNS[] = "Use Static Dns";
constexpr char TEXT_BACK[] = "Back";
} // namespace
WifiStaConfigEntryMenu::WifiStaConfigEntryMenu(int index) :
m_index{index}
{
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigSsidText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigKeyText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigUseStaticIpAccessor, StaticText<TEXT_USESTATICIP>, ToggleBoolAction, CheckboxIcon>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticIpText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticSubnetText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticGatewayText, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigUseStaticDnsAccessor, StaticText<TEXT_USESTATICDNS>, ToggleBoolAction, CheckboxIcon>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticDns0Text, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticDns1Text, DummyAction>>(index);
constructMenuItem<makeComponentArgs<MenuItem, WifiStaConfigStaticDns2Text, DummyAction>>(index);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiStaConfigsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
std::string WifiStaConfigEntryMenu::text() const
{
return fmt::format("Wifi Config {}", m_index + 1);
}
void WifiStaConfigEntryMenu::back()
{
switchScreen<WifiStaConfigsMenu>();
}

16
main/displays/menus/wifistaconfigentrymenu.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
class WifiStaConfigEntryMenu : public BobbyMenuDisplay
{
public:
WifiStaConfigEntryMenu(int index);
std::string text() const override;
void back() override;
private:
const int m_index;
};

77
main/displays/menus/wifistaconfigsmenu.cpp Normal file
View File

@ -0,0 +1,77 @@
#include "wifistaconfigsmenu.h"
// 3rdparty lib includes
#include <menuitem.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <fmt/core.h>
#include <strutils.h>
#include <espwifistack.h>
// local includes
#include "wifistasettingsmenu.h"
#include "wifistaconfigentrymenu.h"
#include "newsettings.h"
using namespace espgui;
namespace {
constexpr char TEXT_BACK[] = "Back";
class WifiStaConfigurationMenuItem : public MenuItem
{
public:
WifiStaConfigurationMenuItem(int index) : m_index{index} {}
void triggered() override;
std::string text() const override;
private:
const int m_index;
};
} // namespace
WifiStaConfigsMenu::WifiStaConfigsMenu()
{
for (int i = 0; i < configs.wifi_configs.size(); i++)
constructMenuItem<WifiStaConfigurationMenuItem>(i);
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiStaSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
std::string WifiStaConfigsMenu::text() const
{
return "Configurations";
}
void WifiStaConfigsMenu::back()
{
switchScreen<WifiStaSettingsMenu>();
}
namespace {
void WifiStaConfigurationMenuItem::triggered()
{
switchScreen<WifiStaConfigEntryMenu>(m_index);
}
std::string WifiStaConfigurationMenuItem::text() const
{
const auto &config = configs.wifi_configs[m_index];
const auto &ssid = config.ssid.value;
bool connected{};
if (!ssid.empty() && wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
if (cpputils::stringEqualsIgnoreCase(std::string_view{reinterpret_cast<const char*>(result->ssid)}, ssid))
connected = true;
return fmt::format("&s{}: &f{}{}",
m_index + 1,
ssid.empty() ? "&1" : (connected ? "&2" : ""),
ssid.empty() ? "<empty>" : ssid);
}
} // namespace

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

@ -0,0 +1,13 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
class WifiStaConfigsMenu : public BobbyMenuDisplay
{
public:
WifiStaConfigsMenu();
std::string text() const override;
void back() override;
};

134
main/displays/menus/wifistascanentrymenu.cpp Normal file
View File

@ -0,0 +1,134 @@
#include "wifistascanentrymenu.h"
// system includes
#include <algorithm>
// esp-idf includes
#include <esp_log.h>
// 3rdparty lib includes
#include <menuitem.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <fmt/format.h>
#include <espwifiutils.h>
#include <richtextrenderer.h>
#include <strutils.h>
// local includes
#include "wifistascanmenu.h"
#include "wifistaconfigentrymenu.h"
#include "wifiguiutils.h"
#include "newsettings.h"
using namespace std::string_literals;
using namespace espgui;
namespace {
constexpr const char * const TAG = "BOBBY";
constexpr char TEXT_SAVEASNEW[] = "Save as new wifi config";
constexpr char TEXT_BACK[] = "Back";
class SaveNewWifiConfigAction : public virtual ActionInterface
{
public:
SaveNewWifiConfigAction(std::string &&ssid) : m_ssid{std::move(ssid)} {}
SaveNewWifiConfigAction(std::string_view ssid) : m_ssid{ssid} {}
void triggered() override;
private:
const std::string m_ssid;
};
} // namespace
WifiStaScanEntryMenu::WifiStaScanEntryMenu(const wifi_ap_record_t &info) :
m_info{info}
{
const std::string_view ssid{reinterpret_cast<const char*>(m_info.ssid)};
const bool configured = std::any_of(std::begin(configs.wifi_configs), std::end(configs.wifi_configs),
[&ssid](const WiFiConfig &config){ return cpputils::stringEqualsIgnoreCase(config.ssid.value, ssid); });
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sssid: &f{}{}", configured?"&4":"", richTextEscape(ssid)));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sconfigured: &f{}{}", configured?"&2":"&1", configured?"yes":"no"));
if (!configured && !ssid.empty())
constructMenuItem<makeComponentArgs<MenuItem, SaveNewWifiConfigAction, StaticText<TEXT_SAVEASNEW>>>(ssid);
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sbssid: &f{}", wifi_stack::toString(wifi_stack::mac_t{m_info.bssid})));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&schannel: &f{}", m_info.primary));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&ssecond: &f{}", [&](){
switch (m_info.second)
{
case WIFI_SECOND_CHAN_NONE: return "NONE"s;
case WIFI_SECOND_CHAN_ABOVE: return "ABOVE"s;
case WIFI_SECOND_CHAN_BELOW: return "BELOW"s;
default: return std::to_string(m_info.second);
}
}()));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&srssi: &f{}{}dB", rssiToColor(m_info.rssi), m_info.rssi));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sauthmode: &f{}", wifi_stack::toString(m_info.authmode)));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&spairwise cipher: &f{}", wifi_stack::toString(m_info.pairwise_cipher)));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sgroup cipher: &f{}", wifi_stack::toString(m_info.group_cipher)));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sant: &f{}", [&](){
switch (m_info.ant)
{
case WIFI_ANT_ANT0: return "ANT0"s;
case WIFI_ANT_ANT1: return "ANT1"s;
default: return std::to_string(m_info.ant);
}
}()));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&smodes:&f{}{}{}", m_info.phy_11b?" b":"", m_info.phy_11g?" g":"", m_info.phy_11n?" n":""));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&slong range: &f{}{}", m_info.phy_lr?"&2":"&1", m_info.phy_lr?"yes":"no"));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&swps: &f{}{}", m_info.wps?"&2":"&1", m_info.wps?"yes":"no"));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sftm responder: &f{}{}", m_info.ftm_responder?"&2":"&1", m_info.ftm_responder?"yes":"no"));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&sftm initiator: &f{}{}", m_info.ftm_initiator?"&2":"&1", m_info.ftm_initiator?"yes":"no"));
constructMenuItem<makeComponentArgs<MenuItem, ChangeableText, DummyAction>>(fmt::format("&scountry: &f{} ({}-{}, {}dB, {})",
std::string_view(m_info.country.cc, m_info.country.cc[0]=='\0' ? 0 : (m_info.country.cc[1]=='\0' ? 1 : (m_info.country.cc[2]=='\0' ? 2 : 3))),
m_info.country.schan,
m_info.country.nchan,
m_info.country.max_tx_power,
[&](){
switch (m_info.country.policy)
{
case WIFI_COUNTRY_POLICY_AUTO: return "AUTO"s;
case WIFI_COUNTRY_POLICY_MANUAL: return "MANUAL"s;
default: return std::to_string(m_info.country.policy);
}
}()));
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiStaScanMenu>, StaticMenuItemIcon<&icons::back>>>();
}
std::string WifiStaScanEntryMenu::text() const
{
return fmt::format("Scan entry {}", richTextEscape(std::string_view{reinterpret_cast<const char*>(m_info.ssid)}));
}
void WifiStaScanEntryMenu::back()
{
switchScreen<WifiStaScanMenu>();
}
namespace {
void SaveNewWifiConfigAction::triggered()
{
const auto iter = std::find_if(std::begin(configs.wifi_configs), std::end(configs.wifi_configs),
[](const WiFiConfig &config){ return config.ssid.value.empty() && config.key.value.empty(); });
if (iter == std::end(configs.wifi_configs))
{
ESP_LOGE(TAG, "no free wifi config slot found!");
return;
}
if (const auto result = configs.write_config(iter->ssid, m_ssid); !result)
{
ESP_LOGE(TAG, "Could not save ssid: %.*s", result.error().size(), result.error().data());
return;
}
switchScreen<WifiStaConfigEntryMenu>(std::distance(std::begin(configs.wifi_configs), iter));
}
} // namespace

19
main/displays/menus/wifistascanentrymenu.h Normal file
View File

@ -0,0 +1,19 @@
#pragma once
// esp-idf includes
#include <esp_wifi_types.h>
// local includes
#include "displays/bobbymenudisplay.h"
class WifiStaScanEntryMenu : public BobbyMenuDisplay
{
public:
WifiStaScanEntryMenu(const wifi_ap_record_t &info);
std::string text() const override;
void back() override;
private:
const wifi_ap_record_t m_info;
};

150
main/displays/menus/wifistascanmenu.cpp Normal file
View File

@ -0,0 +1,150 @@
#include "wifistascanmenu.h"
// system includes
#include <algorithm>
// 3rdparty lib includes
#include <menuitem.h>
#include <actions/switchscreenaction.h>
#include <icons/back.h>
#include <screenmanager.h>
#include <fmt/format.h>
#include <espwifistack.h>
#include <espwifiutils.h>
#include <richtextrenderer.h>
#include <strutils.h>
// local includes
#include "actions/wifistascanaction.h"
#include "actions/wifistascanclearaction.h"
#include "wifistasettingsmenu.h"
#include "wifiguiutils.h"
#include "wifistascanentrymenu.h"
#include "newsettings.h"
using namespace espgui;
namespace {
constexpr char TEXT_STARTSCAN[] = "Start scan";
constexpr char TEXT_CLEARRESULTS[] = "Clear results";
constexpr char TEXT_BACK[] = "Back";
class WifiStaScanMenuItem : public MenuItem
{
public:
WifiStaScanMenuItem(const wifi_ap_record_t &info) : m_info{info} {}
void setInfo(const wifi_ap_record_t &info) { m_info = info; }
void triggered() override;
std::string text() const override;
private:
wifi_ap_record_t m_info;
};
constexpr const size_t extraItemsAtBeginning = 2; // Scan and clear
} // namespace
WifiStaScanMenu::WifiStaScanMenu()
{
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_STARTSCAN>, WifiStaScanAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CLEARRESULTS>, WifiStaScanClearAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<WifiStaSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
std::string WifiStaScanMenu::text() const
{
const auto scanStatus = wifi_stack::get_scan_status();
auto text = fmt::format("Scan {}{}",
[&](){
switch (scanStatus)
{
case wifi_stack::WiFiScanStatus::Scanning: return "&4";
case wifi_stack::WiFiScanStatus::Finished: return "&2";
case wifi_stack::WiFiScanStatus::Failed: return "&1";
default: return "";
}
}(),
wifi_stack::toString(scanStatus));
//if (scanStatus != wifi_stack::WiFiScanStatus::Scanning)
if (const auto &result = wifi_stack::get_scan_result())
text += fmt::format("&c ({} found)", result->entries.size());
return text;
}
void WifiStaScanMenu::back()
{
switchScreen<WifiStaSettingsMenu>();
}
void WifiStaScanMenu::start()
{
Base::start();
m_wasScanning = true;
}
void WifiStaScanMenu::update()
{
const auto scanStatus = wifi_stack::get_scan_status();
if (scanStatus == wifi_stack::WiFiScanStatus::Scanning && !m_wasScanning)
{
m_wasScanning = true;
}
else if (scanStatus != wifi_stack::WiFiScanStatus::Scanning && m_wasScanning)
{
m_wasScanning = false;
auto backButton = takeLastMenuItem();
const auto &result = wifi_stack::get_scan_result();
for (std::size_t i = 0; i < (result ? result->entries.size() : 0); i++)
{
if (menuItemCount() - extraItemsAtBeginning <= i)
constructMenuItem<WifiStaScanMenuItem>(result->entries[i]);
else
((WifiStaScanMenuItem*)(&getMenuItem(i + extraItemsAtBeginning)))->setInfo(result->entries[i]);
}
while (menuItemCount() - extraItemsAtBeginning > (result ? result->entries.size() : 0))
takeLastMenuItem();
emplaceMenuItem(std::move(backButton));
}
Base::update();
}
namespace {
void WifiStaScanMenuItem::triggered()
{
switchScreen<WifiStaScanEntryMenu>(m_info);
}
std::string WifiStaScanMenuItem::text() const
{
const std::string_view ssid{reinterpret_cast<const char*>(m_info.ssid)};
bool connected{};
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
if (wifi_stack::mac_t{result->bssid} == wifi_stack::mac_t{m_info.bssid})
connected = true;
const bool configured = std::any_of(std::begin(configs.wifi_configs), std::end(configs.wifi_configs),
[&ssid](const WiFiConfig &config){ return cpputils::stringEqualsIgnoreCase(config.ssid.value, ssid); });
return fmt::format("&s{}{} {}&f{}",
rssiToColor(m_info.rssi),
m_info.rssi,
connected ? "&2" : (configured ? "&4" : "&c"),
richTextEscape(ssid));
}
} // namespace

21
main/displays/menus/wifistascanmenu.h Normal file
View File

@ -0,0 +1,21 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
class WifiStaScanMenu : public BobbyMenuDisplay
{
using Base = BobbyMenuDisplay;
public:
WifiStaScanMenu();
std::string text() const override;
void back() override;
void start() override;
void update() override;
private:
bool m_wasScanning;
};

57
main/displays/menus/wifistasettingsmenu.cpp Normal file
View File

@ -0,0 +1,57 @@
#include "wifistasettingsmenu.h"
// 3rdparty lib includes
#include <menuitem.h>
#include <actions/dummyaction.h>
#include <actions/switchscreenaction.h>
#include <checkboxicon.h>
#include <actions/toggleboolaction.h>
#include <icons/back.h>
#include <screenmanager.h>
// local includes
#include "wifistascanmenu.h"
#include "wifistaconfigsmenu.h"
#include "accessors/wifistaconfigaccessors.h"
#include "networksettingsmenu.h"
#include "texthelpers/wifistatexthelpers.h"
using namespace espgui;
namespace {
constexpr char TEXT_ENABLED[] = "Enabled";
constexpr char TEXT_CONFIGURATIONS[] = "Configurations";
constexpr char TEXT_BACK[] = "Back";
} // namespace
WifiStaSettingsMenu::WifiStaSettingsMenu()
{
constructMenuItem<makeComponent<MenuItem, WifiStaStatusText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaMacText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaScanStatusText, SwitchScreenAction<WifiStaScanMenu>>>();
constructMenuItem<makeComponent<MenuItem, WifiSsidText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiBssidText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiRssiText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiAuthmodeText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiPairwiseCipherText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiGroupCipherText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaIpText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaNetmaskText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaGatewayText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaHostnameText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaIpv6LinklocalText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, WifiStaIpv6GlobalText, DummyAction>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_ENABLED>, ToggleBoolAction, CheckboxIcon, WifiStaEnabledAccessor>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_CONFIGURATIONS>, SwitchScreenAction<WifiStaConfigsMenu>>>();
constructMenuItem<makeComponent<MenuItem, StaticText<TEXT_BACK>, SwitchScreenAction<NetworkSettingsMenu>, StaticMenuItemIcon<&icons::back>>>();
}
std::string WifiStaSettingsMenu::text() const
{
return "Sta Settings";
}
void WifiStaSettingsMenu::back()
{
switchScreen<NetworkSettingsMenu>();
}

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

@ -0,0 +1,13 @@
#pragma once
// local includes
#include "displays/bobbymenudisplay.h"
class WifiStaSettingsMenu : public BobbyMenuDisplay
{
public:
WifiStaSettingsMenu();
std::string text() const override;
void back() override;
};

4
main/newsettings.h
View File

@ -57,7 +57,7 @@ public:
// default allowReset constraints nvsName
ConfigWrapper<std::optional<mac_t>> baseMacAddressOverride{std::nullopt, NoReset, {}, "baseMacAddrOver" };
ConfigWrapper<std::string> hostname {defaultHostname, DoReset, StringMinMaxSize<4, 32>, "hostname" };
ConfigWrapper<bool> wifiStaEnabled {true, DoReset, {}, "wifi_enabled" };
ConfigWrapper<bool> wifiStaEnabled {true, DoReset, {}, "wifiStaEnabled" };
std::array<WiFiConfig, 10> wifi_configs {
WiFiConfig {"wifi_ssid0", "wifi_key0", "wifi_usestatic0", "wifi_static_ip0", "wifi_stati_sub0", "wifi_stat_gate0", "wifi_usestadns0", "wifi_stat_dnsA0", "wifi_stat_dnsB0", "wifi_stat_dnsC0"},
WiFiConfig {"wifi_ssid1", "wifi_key1", "wifi_usestatic1", "wifi_static_ip1", "wifi_stati_sub1", "wifi_stat_gate1", "wifi_usestadns1", "wifi_stat_dnsA1", "wifi_stat_dnsB1", "wifi_stat_dnsC1"},
@ -73,7 +73,7 @@ public:
ConfigWrapper<int8_t> wifiStaMinRssi {-90, DoReset, {}, "wifiStaMinRssi" };
ConfigWrapper<bool> wifiApEnabled {true, DoReset, {}, "wifiApEnabled" };
ConfigWrapper<std::string> wifiApName {defaultHostname, DoReset, StringMinMaxSize<4, 32>, "wifiApName" };
ConfigWrapper<std::string> wifiApName {defaultHostname, DoReset, StringMinMaxSize<4, 32>, "wifiApName" };
ConfigWrapper<std::string> wifiApKey {"Passwort_123", DoReset, StringOr<StringEmpty, StringMinMaxSize<8, 64>>, "wifiApKey" };
ConfigWrapper<uint8_t> wifiApChannel {1, DoReset, {}, "wifiApChannel" };
ConfigWrapper<wifi_auth_mode_t> wifiApAuthmode{WIFI_AUTH_WPA2_PSK, DoReset, {}, "wifiApAuthmode" };

42
main/texthelpers/networktexthelpers.cpp Normal file
View File

@ -0,0 +1,42 @@
#include "networktexthelpers.h"
// esp-idf
#include <esp_system.h>
#include <lwip/dns.h>
// 3rdparty lib includes
#include <espwifistack.h>
#include <espwifiutils.h>
#include <fmt/format.h>
using namespace espgui;
std::string WifiDefaultMacText::text() const
{
std::string text = "&sdefault-mac: &f";
wifi_stack::mac_t mac;
if (const auto result = esp_efuse_mac_get_default(std::begin(mac)); result == ESP_OK)
text += wifi_stack::toString(mac);
else
text += fmt::format("&1{}", esp_err_to_name(result));
return text;
}
std::string WifiBaseMacText::text() const
{
std::string text = "&sbase-mac: &f";
wifi_stack::mac_t mac;
if (const auto result = esp_base_mac_addr_get(std::begin(mac)); result == ESP_OK)
text += wifi_stack::toString(mac);
else
text += fmt::format("&1{}", esp_err_to_name(result));
return text;
}
std::string DnsText::text() const
{
std::string text = fmt::format("&sdns{}: &f", m_index);
if (const ip_addr_t *dns_ip = dns_getserver(m_index))
text += wifi_stack::toString(*dns_ip);
return text;
}

27
main/texthelpers/networktexthelpers.h Normal file
View File

@ -0,0 +1,27 @@
#pragma once
// 3rdparty lib includes
#include <textinterface.h>
class WifiDefaultMacText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiBaseMacText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class DnsText : public virtual espgui::TextInterface
{
public:
DnsText(uint8_t index) : m_index{index} {}
std::string text() const override;
private:
const uint8_t m_index;
};

63
main/texthelpers/wifiaptexthelpers.cpp Normal file
View File

@ -0,0 +1,63 @@
#include "wifiaptexthelpers.h"
// esp-idf includes
#include <esp_wifi.h>
// 3rdparty lib includes
#include <fmt/core.h>
#include <espwifistack.h>
#include <richtextrenderer.h>
// local includes
#include "newsettings.h"
#include "wifi_bobbycar.h"
using namespace espgui;
std::string WifiApNameText::text() const
{
return fmt::format("&sssid: &f{}", richTextEscape(configs.wifiApName.value));
}
std::string WifiApKeyText::text() const
{
return fmt::format("&skey: &f{}", richTextEscape(configs.wifiApKey.value));
}
std::string WifiApMacText::text() const
{
std::string text = "&smac: &f";
wifi_stack::mac_t mac;
if (const auto result = esp_wifi_get_mac(WIFI_IF_AP, std::begin(mac)); result == ESP_OK)
text += wifi_stack::toString(mac);
else
text += fmt::format("&1{}", esp_err_to_name(result));
return text;
}
std::string WifiApIpText::text() const
{
return fmt::format("&sip: &f{}", wifi_stack::toString(apIP));
}
std::string WifiApMaskText::text() const
{
return fmt::format("&smask: &f{}", wifi_stack::toString(netMsk));
}
std::string WifiApHostnameText::text() const
{
if (auto hostname = wifi_stack::get_hostname_for_interface(ESP_IF_WIFI_AP))
return fmt::format("&shostname: &f{}", espgui::richTextEscape(*hostname));
else
return fmt::format("&shostname: &1{}", espgui::richTextEscape(std::move(hostname).error()));
}
std::string WifiApClientsText::text() const
{
wifi_sta_list_t clients;
if (const auto result = esp_wifi_ap_get_sta_list(&clients); result == ESP_OK)
return fmt::format("Clients ({})", clients.num);
else
return fmt::format("&7Clients &1{}", esp_err_to_name(result));
}

46
main/texthelpers/wifiaptexthelpers.h Normal file
View File

@ -0,0 +1,46 @@
#pragma once
// 3rdparty lib includes
#include <textinterface.h>
class WifiApNameText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiApKeyText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiApMacText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiApIpText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiApMaskText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiApHostnameText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiApClientsText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};

51
main/texthelpers/wifistaconfigtexthelpers.cpp Normal file
View File

@ -0,0 +1,51 @@
#include "wifistaconfigtexthelpers.h"
// 3rdparty lib includes
#include <fmt/core.h>
#include <richtextrenderer.h>
#include <espwifiutils.h>
// local includes
#include "newsettings.h"
using namespace espgui;
std::string WifiStaConfigSsidText::text() const
{
return fmt::format("&sssid: &f{}", richTextEscape(configs.wifi_configs[m_index].ssid.value));
}
std::string WifiStaConfigKeyText::text() const
{
return fmt::format("&skey: &f{}", richTextEscape(configs.wifi_configs[m_index].key.value));
}
std::string WifiStaConfigStaticIpText::text() const
{
return fmt::format("&sStatic Ip: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticIp.value));
}
std::string WifiStaConfigStaticSubnetText::text() const
{
return fmt::format("&sStatic Mask: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticSubnet.value));
}
std::string WifiStaConfigStaticGatewayText::text() const
{
return fmt::format("&sStatic Gw: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticGateway.value));
}
std::string WifiStaConfigStaticDns0Text::text() const
{
return fmt::format("&sStatic Dns0: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticDns0.value));
}
std::string WifiStaConfigStaticDns1Text::text() const
{
return fmt::format("&sStatic Dns1: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticDns1.value));
}
std::string WifiStaConfigStaticDns2Text::text() const
{
return fmt::format("&sStatic Dns2: &f{}", wifi_stack::toString(configs.wifi_configs[m_index].staticDns2.value));
}

92
main/texthelpers/wifistaconfigtexthelpers.h Normal file
View File

@ -0,0 +1,92 @@
#pragma once
// 3rdparty lib includes
#include <textinterface.h>
class WifiStaConfigSsidText : public virtual espgui::TextInterface
{
public:
WifiStaConfigSsidText(int index) : m_index{index} {}
std::string text() const override;
private:
const int m_index;
};
class WifiStaConfigKeyText : public virtual espgui::TextInterface
{
public:
WifiStaConfigKeyText(int index) : m_index{index} {}
std::string text() const override;
private:
const int m_index;
};
class WifiStaConfigStaticIpText : public virtual espgui::TextInterface
{
public:
WifiStaConfigStaticIpText(int index) : m_index{index} {}
std::string text() const override;
private:
const int m_index;
};
class WifiStaConfigStaticSubnetText : public virtual espgui::TextInterface
{
public:
WifiStaConfigStaticSubnetText(int index) : m_index{index} {}
std::string text() const override;
private:
const int m_index;
};
class WifiStaConfigStaticGatewayText : public virtual espgui::TextInterface
{
public:
WifiStaConfigStaticGatewayText(int index) : m_index{index} {}
std::string text() const override;
private:
const int m_index;
};
class WifiStaConfigStaticDns0Text : public virtual espgui::TextInterface
{
public:
WifiStaConfigStaticDns0Text(int index) : m_index{index} {}
std::string text() const override;
private:
const int m_index;
};
class WifiStaConfigStaticDns1Text : public virtual espgui::TextInterface
{
public:
WifiStaConfigStaticDns1Text(int index) : m_index{index} {}
std::string text() const override;
private:
const int m_index;
};
class WifiStaConfigStaticDns2Text : public virtual espgui::TextInterface
{
public:
WifiStaConfigStaticDns2Text(int index) : m_index{index} {}
std::string text() const override;
private:
const int m_index;
};

149
main/texthelpers/wifistatexthelpers.cpp Normal file
View File

@ -0,0 +1,149 @@
#include "wifistatexthelpers.h"
// 3rdparty lib includes
#include <fmt/core.h>
#include <espwifistack.h>
#include <richtextrenderer.h>
// local includes
#include "wifiguiutils.h"
using namespace espgui;
std::string WifiStaStatusText::text() const
{
const auto staStatus = wifi_stack::get_sta_status();
return fmt::format("&sstatus: &f{}{}",
staStatus == wifi_stack::WiFiStaStatus::CONNECTED ? "&2" : "",
wifi_stack::toString(staStatus));
}
std::string WifiStaMacText::text() const
{
std::string text = "&smac: &f";
wifi_stack::mac_t mac;
if (const auto result = esp_wifi_get_mac(WIFI_IF_STA, std::begin(mac)); result == ESP_OK)
text += wifi_stack::toString(mac);
else
text += fmt::format("&1{}", esp_err_to_name(result));
return text;
}
std::string WifiStaScanStatusText::text() const
{
const auto status = wifi_stack::get_scan_status();
return fmt::format("Scan {}{}",
status == wifi_stack::WiFiScanStatus::Finished ? "&2" : "",
wifi_stack::toString(status));
}
std::string WifiSsidText::text() const
{
std::string text = "&sssid: &f";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += richTextEscape(std::string_view{reinterpret_cast<const char*>(result->ssid)});
return text;
}
std::string WifiBssidText::text() const
{
std::string text = "&sbssid: &f";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(wifi_stack::mac_t{result->bssid});
return text;
}
std::string WifiRssiText::text() const
{
std::string text = "&srssi: &f";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += fmt::format("{}{}dB", rssiToColor(result->rssi), result->rssi);
return text;
}
std::string WifiAuthmodeText::text() const
{
std::string text = "&sauthmode: &f";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(result->authmode);
return text;
}
std::string WifiPairwiseCipherText::text() const
{
std::string text = "&spairwCiph: &f";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(result->pairwise_cipher);
return text;
}
std::string WifiGroupCipherText::text() const
{
std::string text = "&sgroupCiph: &f";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(result->group_cipher);
return text;
}
std::string WifiStaIpText::text() const
{
std::string text = "&sip: &f";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
text += wifi_stack::toString(result->ip);
return text;
}
std::string WifiStaNetmaskText::text() const
{
std::string text = "&smask: &f";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
text += wifi_stack::toString(result->netmask);
return text;
}
std::string WifiStaGatewayText::text() const
{
std::string text = "&sgw: &f";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
text += wifi_stack::toString(result->gw);
return text;
}
std::string WifiStaHostnameText::text() const
{
if (auto hostname = wifi_stack::get_hostname_for_interface(ESP_IF_WIFI_STA))
return fmt::format("&shostname: &f{}", espgui::richTextEscape(*hostname));
else
return fmt::format("&shostname: &1{}", espgui::richTextEscape(std::move(hostname).error()));
}
std::string WifiStaIpv6LinklocalText::text() const
{
std::string text = "&sipv6-loc: &f";
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);
else
text += fmt::format("&1{}", esp_err_to_name(result));
return text;
}
std::string WifiStaIpv6GlobalText::text() const
{
std::string text = "&sipv6-glo: &f";
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);
else
text += fmt::format("&1{}", esp_err_to_name(result));
return text;
}

94
main/texthelpers/wifistatexthelpers.h Normal file
View File

@ -0,0 +1,94 @@
#pragma once
// 3rdparty lib includes
#include <textinterface.h>
class WifiStaStatusText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiStaMacText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiStaScanStatusText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiSsidText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiBssidText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiRssiText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiAuthmodeText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiPairwiseCipherText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiGroupCipherText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiStaIpText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiStaNetmaskText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiStaGatewayText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiStaHostnameText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiStaIpv6LinklocalText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiStaIpv6GlobalText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};

2
main/texts.cpp
View File

@ -131,7 +131,7 @@ char TEXT_VOLTAGECALIBRATION_VALUE_50_BACK[] = "50V Back";
//char TEXT_SETTINGS[] = "Settings";
char TEXT_BACKLIGHT[] = "Backlight";
char TEXT_LIMITSSETTINGS[] = "Limits settings";
char TEXT_WIFISETTINGS[] = "WiFi settings";
char TEXT_NETWORKSETTINGS[] = "Network settings";
//char TEXT_BLUETOOTHSETTINGS[] = "Bluetooth settings";
//char TEXT_BLESETTINGS[] = "BLE settings";
//char TEXT_CLOUDSETTINGS[] = "Cloud settings";

2
main/texts.h
View File

@ -130,7 +130,7 @@ extern char TEXT_VOLTAGECALIBRATION_VALUE_50_BACK[];
//extern char TEXT_SETTINGS[];
extern char TEXT_BACKLIGHT[];
extern char TEXT_LIMITSSETTINGS[];
extern char TEXT_WIFISETTINGS[];
extern char TEXT_NETWORKSETTINGS[];
//extern char TEXT_BLUETOOTHSETTINGS[];
//extern char TEXT_BLESETTINGS[];
//extern char TEXT_CLOUDSETTINGS[];

2
main/webserver_displaycontrol.cpp
View File

@ -35,7 +35,6 @@ constexpr const char * const TAG = "BOBBYWEB";
esp_err_t webserver_root_handler(httpd_req_t *req)
{
#ifndef FEATURE_IS_MIR_EGAL_OB_DER_WEBSERVER_KORREKT_ARBEITET
ESP_LOGI(TAG, "locking...");
espcpputils::LockHelper helper{webserver_lock->handle, std::chrono::ceil<espcpputils::ticks>(5s).count()};
if (!helper.locked())
{
@ -43,7 +42,6 @@ esp_err_t webserver_root_handler(httpd_req_t *req)
ESP_LOGE(TAG, "%.*s", msg.size(), msg.data());
CALL_AND_EXIT(esphttpdutils::webserver_resp_send, req, esphttpdutils::ResponseStatus::BadRequest, "text/plain", msg);
}
ESP_LOGI(TAG, "succeeded");
#endif
std::string body;

10
main/webserver_newsettings.cpp
View File

@ -207,6 +207,16 @@ esp_err_t webserver_newSettings_handler(httpd_req_t *req)
HtmlTag buttonTag{"button", "type=\"submit\"", body};
body += "Save";
}
{
HtmlTag divTag{"div", "class=\"form-table-cell\"", body};
if (config.touched())
{
HtmlTag buttonTag{"span", "style=\"color: red;\"", body};
body += "Touched";
}
}
});
}
}

9
main/wifiguiutils.cpp Normal file
View File

@ -0,0 +1,9 @@
#include "wifiguiutils.h"
std::string rssiToColor(int8_t rssi)
{
if (rssi < -80) return "&1"; // red
else if (rssi < -60) return "&4"; // yellow
else if (rssi > -40) return "&2"; // green
return {};
}

6
main/wifiguiutils.h Normal file
View File

@ -0,0 +1,6 @@
#pragma once
// system includes
#include <string>
std::string rssiToColor(int8_t rssi);

167
main/wifitexthelpers.cpp
View File

@ -1,167 +0,0 @@
#include "wifitexthelpers.h"
// 3rdparty lib includes
#include <fmt/core.h>
#include <espwifistack.h>
#include <esp_netif.h>
#include <lwip/dns.h>
std::string WifiStatusText::text() const
{
return fmt::format("Status: {}", wifi_stack::toString(wifi_stack::get_sta_status()));
}
std::string WifiScanStatusText::text() const
{
return fmt::format("ScanStatus: {}", wifi_stack::toString(wifi_stack::get_scan_status()));
}
std::string WifiHostnameText::text() const
{
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;
}
std::string WifiMacText::text() const
{
std::string text = "MAC: ";
if (const auto result = wifi_stack::get_base_mac_addr())
text += wifi_stack::toString(*result);
return text;
}
std::string WifiSsidText::text() const
{
std::string text = "SSID: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += std::string_view{reinterpret_cast<const char*>(result->ssid)};
return text;
}
std::string WifiBssidText::text() const
{
std::string text = "BSSID: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(wifi_stack::mac_t{result->bssid});
return text;
}
std::string WifiRssiText::text() const
{
std::string text = "RSSI: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += fmt::format("{}dB", result->rssi);
return text;
}
std::string WifiEncryptionTypeText::text() const
{
std::string text = "encryptionType: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(result->authmode);
return text;
}
std::string WifiPairwiseCipherText::text() const
{
std::string text = "pairwiseCipher: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(result->pairwise_cipher);
return text;
}
std::string WifiGroupCipherText::text() const
{
std::string text = "groupCipher: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto &result = wifi_stack::get_sta_ap_info(); result)
text += wifi_stack::toString(result->group_cipher);
return text;
}
std::string WifiIpText::text() const
{
std::string text = "ip: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
text += wifi_stack::toString(result->ip);
return text;
}
std::string WifiNetmaskText::text() const
{
std::string text = "netmask: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
text += wifi_stack::toString(result->netmask);
return text;
}
std::string WifiGatewayText::text() const
{
std::string text = "gateway: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const auto result = wifi_stack::get_ip_info(TCPIP_ADAPTER_IF_STA); result)
text += wifi_stack::toString(result->gw);
return text;
}
std::string WifiIpv6LinklocalText::text() const
{
std::string text = "ipv6: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::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;
}
std::string WifiIpv6GlobalText::text() const
{
std::string text = "ipv6: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::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;
}
std::string WifiDns0Text::text() const
{
std::string text = "dns0: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const ip_addr_t *dns_ip = dns_getserver(0))
text += wifi_stack::toString(*dns_ip);
return text;
}
std::string WifiDns1Text::text() const
{
std::string text = "dns1: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const ip_addr_t *dns_ip = dns_getserver(1))
text += wifi_stack::toString(*dns_ip);
return text;
}
std::string WifiDns2Text::text() const
{
std::string text = "dns2: ";
if (wifi_stack::get_sta_status() == wifi_stack::WiFiStaStatus::CONNECTED)
if (const ip_addr_t *dns_ip = dns_getserver(2))
text += wifi_stack::toString(*dns_ip);
return text;
}

129
main/wifitexthelpers.h
View File

@ -1,129 +0,0 @@
#pragma once
// local includes
#include "textinterface.h"
class WifiStatusText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiScanStatusText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiHostnameText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiMacText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiSsidText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiBssidText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiRssiText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiEncryptionTypeText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiPairwiseCipherText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiGroupCipherText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiIpText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiNetmaskText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiGatewayText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiIpv6LinklocalText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiIpv6GlobalText : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiDns0Text : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiDns1Text : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
class WifiDns2Text : public virtual espgui::TextInterface
{
public:
std::string text() const override;
};
constexpr char TEXT_SOFTAPGETSTATIONNUM[] = "softAPgetStationNum: ";
using WifiSoftApGetStationNumText = espgui::StaticText<TEXT_SOFTAPGETSTATIONNUM>; //StatusTextHelper<TEXT_SOFTAPGETSTATIONNUM, &WiFi.softAPgetStationNum>
constexpr char TEXT_SOFTAPIP[] = "softAPIP: ";
using WifiSoftApIpText = espgui::StaticText<TEXT_SOFTAPIP>; //StatusTextHelper<TEXT_SOFTAPIP, &WiFi.softAPIP>
constexpr char TEXT_SOFTAPBROADCASTIP[] = "softAPBroadcastIP: ";
using WifiSoftApBroadcastIpText = espgui::StaticText<TEXT_SOFTAPBROADCASTIP>; //StatusTextHelper<TEXT_SOFTAPBROADCASTIP, &WiFi.softAPBroadcastIP>
constexpr char TEXT_SOFTAPNETWORKID[] = "softAPNetworkID: ";
using WifiSoftApNetworkIdText = espgui::StaticText<TEXT_SOFTAPNETWORKID>; //StatusTextHelper<TEXT_SOFTAPNETWORKID, &WiFi.softAPNetworkID>
constexpr char TEXT_SOFTAPSUBNETCIDR[] = "softAPSubnetCIDR: ";
using WifiSoftApSubnetCidrText = espgui::StaticText<TEXT_SOFTAPSUBNETCIDR>; //StatusTextHelper<TEXT_SOFTAPSUBNETCIDR, &WiFi.softAPSubnetCIDR>
constexpr char TEXT_SOFTAPIPV6[] = "softAPIPv6: ";
using WifiSoftApIpV6Text = espgui::StaticText<TEXT_SOFTAPIPV6>; //StatusTextHelper<TEXT_SOFTAPIPV6, &WiFi.softAPIPv6>
constexpr char TEXT_SOFTAPGETHOSTNAME[] = "softAPgetHostname: ";
using WifiSoftApHostnameText = espgui::StaticText<TEXT_SOFTAPGETHOSTNAME>; //StatusTextHelper<TEXT_SOFTAPGETHOSTNAME, &WiFi.softAPgetHostname>
constexpr char TEXT_SOFTAPMACADDRESS[] = "softAPmacAddress: ";
using WifiSoftApMacAddressText = espgui::StaticText<TEXT_SOFTAPMACADDRESS>; //StatusTextHelper<TEXT_SOFTAPMACADDRESS, &WiFi.softAPmacAddress>