tobimai/waterlevel-software
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Updates
Some checks failed
Test compiling project / test (push) Failing after 0s
Details

Browse Source
This commit is contained in:
Tobias Maier
2025-11-02 12:50:10 +01:00
parent f0e237cd71
commit 27ebbe22ac
14 changed files with 221 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
src/main.cpp
View File

@@ -24,9 +24,9 @@
#include "networking/json_builder.h"
#include "networking/responses.h"
#include <fetchOTA.h>
#include <ESP32Ping.h>
#include "time.h"
#include "tools/log.h"
#include <LittleFS.h>
#define MYLOG 0
@@ -37,68 +37,64 @@ extern DeviceTelemetry telemetry;
extern NetworkData wifi_data;
extern NetworkData ethernet_data;
extern SensorData shunt_data;
extern ActiveErrors active_errors;
extern "C" int rom_phy_get_vdd33();
Version current_spiffs_version;
AsyncWebServer server(80);
AsyncWebSocket webSocket("/webSocket");
// AsyncWebSocket webSocket("/webSocket");
#define FORMAT_LITTLEFS_IF_FAILED true
void setup()
{
logger.registerSerial(MYLOG, DEBUG, "tst");
{
Logger.registerSerial(MYLOG, ELOG_LEVEL_DEBUG, "Serial");
LOG(ELOG_LEVEL_DEBUG, "Init LEDs");
led_setup();
prefs.begin("waterlevel", false);
Serial.begin(115200);
LOG(DEBUG, "Init LEDs");
pinMode(LED_1, OUTPUT);
pinMode(LED_2, OUTPUT);
pinMode(LED_3, OUTPUT);
pinMode(LED_4, OUTPUT);
pinMode(LED_5, OUTPUT);
pinMode(LED_RED, OUTPUT);
display_error_code(31);
delay(500);
display_error_code(17);
init_sensor();
LOG(DEBUG, "Beginning SPIFFS");
SPIFFS.begin(true);
LOG(ELOG_LEVEL_DEBUG, "Beginning SPIFFS");
//SPIFFS.begin(FORMAT_LITTLEFS_IF_FAILED);
LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED);
// Read the current SPIFFS version from the versions file on the spiffs
File file = SPIFFS.open("/version", FILE_READ);
File file = LittleFS.open("/version", FILE_READ);
if (!file) {
Serial.println("Failed to open version file for reading");
} else {
String version = file.readStringUntil('\n');
LOG(DEBUG, "Version: %s", version);
LOG(ELOG_LEVEL_DEBUG, "Version: %s", version);
current_spiffs_version = parseVersion(version.c_str());
LOG(DEBUG, "Current SPIFFS Version: %d.%d.%d", current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch);
LOG(ELOG_LEVEL_DEBUG, "Current SPIFFS Version: %d.%d.%d", current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch);
}
LOG(DEBUG, "SPIFFS initialized");
display_error_code(19);
LOG(ELOG_LEVEL_DEBUG, "SPIFFS initialized");
LOG(DEBUG, "Begin INA");
LOG(ELOG_LEVEL_DEBUG, "Begin INA");
display_error_code(22);
/////////////////////////////// ROUTES ///////////////////////////////
LOG(DEBUG, "Route Setup");
LOG(ELOG_LEVEL_DEBUG, "Route Setup");
// Normal HTML stuff
server.on("/", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/status.html", "text/html", false, processor); });
server.on("/", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/status.html", "text/html", false, processor); });
server.on("/settings", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/settings.html", "text/html", false, processor); });
server.on("/settings", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/settings.html", "text/html", false, processor); });
server.on("/export", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/data_export.html", "text/html", false); });
server.on("/export", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/data_export.html", "text/html", false); });
server.on("/logic.js", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/logic.js", "application/javascript", false, processor); });
server.on("/logic.js", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/logic.js", "application/javascript", false, processor); });
server.on("/update", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/update_progress.html", "text/html", false, processor); });
server.on("/update", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/update_progress.html", "text/html", false, processor); });
// API stuff - internal
server.on("/update_wifi_credentials", HTTP_POST, [](AsyncWebServerRequest* request) {
@@ -106,27 +102,27 @@ void setup()
// For settings SSID
if (request->hasParam(ssid_key, true) && request->hasParam(wifi_password_key, true)) {
LOG(DEBUG, "Updating SSID config");
AsyncWebParameter* ssid_param = request->getParam(ssid_key, true);
AsyncWebParameter* password_param = request->getParam(wifi_password_key, true);
LOG(ELOG_LEVEL_DEBUG, "Updating SSID config");
const AsyncWebParameter* ssid_param = request->getParam(ssid_key, true);
const AsyncWebParameter* password_param = request->getParam(wifi_password_key, true);
prefs.putString(ssid_key, ssid_param->value().c_str());
prefs.putString(wifi_password_key, password_param->value().c_str());
} else {
request->send(400, "text/plain", "Missing parameters"); // TODO add proper error messages
}
request->send(SPIFFS, "/settings.html", "text/html", false, processor); // TODO add proper return templating
request->send(LittleFS, "/settings.html", "text/html", false, processor); // TODO add proper return templating
});
server.on("/update_sensor_settings", HTTP_POST, [](AsyncWebServerRequest* request) {
int params = request->params();
if (request->hasParam(level_sensor_range_key, true) && request->hasParam(water_level_min_key, true) && request->hasParam(water_level_max_key, true) && request->hasParam(water_volume_key, true)) {
LOG(DEBUG, "Updating Sensor config");
AsyncWebParameter* range_param = request->getParam(level_sensor_range_key, true);
AsyncWebParameter* level_min_param = request->getParam(water_level_min_key, true);
AsyncWebParameter* level_max_param = request->getParam(water_level_max_key, true);
AsyncWebParameter* liters_param = request->getParam(water_volume_key, true);
LOG(ELOG_LEVEL_DEBUG, "Updating Sensor config");
const AsyncWebParameter* range_param = request->getParam(level_sensor_range_key, true);
const AsyncWebParameter* level_min_param = request->getParam(water_level_min_key, true);
const AsyncWebParameter* level_max_param = request->getParam(water_level_max_key, true);
const AsyncWebParameter* liters_param = request->getParam(water_volume_key, true);
String range_str = range_param->value();
String level_min_str = level_min_param->value();
@@ -144,44 +140,42 @@ void setup()
// Convert the C string to a float using strtod
float value = strtod(paramCStr, &endPtr);
LOG(DEBUG, "range_float:%D:", range_float);
LOG(ELOG_LEVEL_DEBUG, "range_float:%D:", range_float);
prefs.putFloat(level_sensor_range_key, range_float);
prefs.putFloat(water_level_min_key, level_min_float);
prefs.putFloat(water_level_max_key, level_max_float);
prefs.putFloat(water_volume_key, liters_float);
LOG(DEBUG, "range_float_after:%D:", prefs.getFloat(level_sensor_range_key, -1.0));
LOG(ELOG_LEVEL_DEBUG, "range_float_after:%D:", prefs.getFloat(level_sensor_range_key, -1.0));
} else {
LOG(DEBUG, "!!!! FAIL lo");
LOG(ELOG_LEVEL_DEBUG, "!!!! FAIL lo");
for (int i = 0; i < params; i++) {
AsyncWebParameter* p = request->getParam(i);
const AsyncWebParameter* p = request->getParam(i);
if (p->isFile()) { // p->isPost() is also true
LOG(DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
LOG(ELOG_LEVEL_DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
} else if (p->isPost()) {
LOG(DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
LOG(ELOG_LEVEL_DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
} else {
LOG(DEBUG, "GET[%s]: %s\n", p->name().c_str(), p->value().c_str());
LOG(ELOG_LEVEL_DEBUG, "GET[%s]: %s\n", p->name().c_str(), p->value().c_str());
}
}
request->send(400, "text/plain", "Missing parameters"); // TODO add proper error messages
}
request->send(SPIFFS, "/settings.html", "text/html", false); // TODO add proper return templating
request->send(LittleFS, "/settings.html", "text/html", false); // TODO add proper return templating
});
setup_api_endpoints();
display_error_code(23);
webSocket.onEvent(onWsEvent);
server.addHandler(&webSocket);
// webSocket.onEvent(onWsEvent);
// server.addHandler(&webSocket);
server.on("/chota.css", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/chota.css", "text/css", false); });
server.on("/gauge.js", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/gauge.js", "application/javascript", false); });
server.on("/chota.css", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/chota.css", "text/css", false); });
server.on("/gauge.js", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(LittleFS, "/gauge.js", "application/javascript", false); });
display_error_code(24);
LOG(DEBUG, "OTA Setup");
LOG(ELOG_LEVEL_DEBUG, "OTA Setup");
ArduinoOTA
.onStart([]() {
String type;
@@ -191,39 +185,39 @@ void setup()
type = "filesystem";
// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
LOG(DEBUG, "Start updating %s", type); })
.onEnd([]() { LOG(DEBUG, "\nEnd"); })
LOG(ELOG_LEVEL_DEBUG, "Start updating %s", type); })
.onEnd([]() { LOG(ELOG_LEVEL_DEBUG, "\nEnd"); })
.onProgress([](unsigned int progress, unsigned int total) { Serial.printf("Progress: %u%%\r", (progress / (total / 100))); })
.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) LOG(DEBUG, "Auth Failed");
else if (error == OTA_BEGIN_ERROR) LOG(DEBUG, "Begin Failed");
else if (error == OTA_CONNECT_ERROR) LOG(DEBUG, "Connect Failed");
else if (error == OTA_RECEIVE_ERROR) LOG(DEBUG, "Receive Failed");
else if (error == OTA_END_ERROR) LOG(DEBUG, "End Failed"); });
if (error == OTA_AUTH_ERROR) LOG(ELOG_LEVEL_DEBUG, "Auth Failed");
else if (error == OTA_BEGIN_ERROR) LOG(ELOG_LEVEL_DEBUG, "Begin Failed");
else if (error == OTA_CONNECT_ERROR) LOG(ELOG_LEVEL_DEBUG, "Connect Failed");
else if (error == OTA_RECEIVE_ERROR) LOG(ELOG_LEVEL_DEBUG, "Receive Failed");
else if (error == OTA_END_ERROR) LOG(ELOG_LEVEL_DEBUG, "End Failed"); });
display_error_code(26);
digitalWrite(LED_RED, 0);
// Starting bootup sequence
xTaskCreate(ethernet_task, "EthernetTask", 4096, NULL, 1, NULL);
xTaskCreate(wifi_task, "WiFiTask", 10000, NULL, 1, NULL);
esp_netif_t* eth = esp_netif_get_handle_from_ifkey("ETH_DEF");
esp_netif_t* wifi = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
// Create Etnernet task and wait a second to see if there is connection
LOG(DEBUG, "Started Ethernet, waiting");
delay(2000);
if (ETH.linkUp()){
LOG(DEBUG, "Ethernet connected, starting update checker");
LOG(ELOG_LEVEL_DEBUG, "Ethernet connected, starting update checker");
xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 8, NULL, 1, NULL);
} else {
LOG(DEBUG, "Ethernet not connected, starting update checker and WiFi Task");
xTaskCreate(wifi_task, "WiFiTask", 10000, NULL, 1, NULL);
LOG(ELOG_LEVEL_DEBUG, "Ethernet not connected, starting update checker and WiFi Task");
// esp_netif_set_default_netif(esp_netif_get_handle_from_ifkey("ETH_DEF"));
xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 8, NULL, 1, NULL);
delay(2000);
}
LOG(DEBUG, "Getting time now");
LOG(ELOG_LEVEL_DEBUG, "Getting time now");
// Configure time to UTC
configTime(0, 0, "pool.ntp.org");
@@ -245,44 +239,24 @@ void setup()
// Sanity check: Ensure the year is at least 2020.
int currentYear = timeinfo.tm_year + 1900; // tm_year is years since 1900
if (currentYear < 2020) {
LOG(DEBUG, "Time not set properly: ");
LOG(ELOG_LEVEL_DEBUG, "Time not set properly: ");
} else {
LOG(DEBUG, "Time is valid: %s", asctime(&timeinfo));
LOG(ELOG_LEVEL_DEBUG, "Time is valid: %s", asctime(&timeinfo));
}
// Setup syslog
logger.configureSyslog("192.168.6.11", 5514, "esp32");
logger.registerSyslog(MYLOG, DEBUG, FAC_USER, "waterlevel");
LOG(ERROR, "Here is an error message, error code: %d", 17);
LOG(ELOG_LEVEL_ERROR, "Here is an error message, error code: %d", 17);
LOG(DEBUG, "Starting webserver");
LOG(ELOG_LEVEL_DEBUG, "Starting webserver");
server.begin();
ArduinoOTA.begin();
display_error_code(25);
xTaskCreate(display_task, "DisplayTask", 10000, NULL, 1, NULL);
xTaskCreate(read_sensor_task, "ReadSensorTask", 1024 * 4, NULL, 1, NULL);
xTaskCreate(collect_internal_telemetry_task, "InternalTelemetryTask", 2048, NULL, 1, NULL);
// Wait until there is network connection
while (true) {
if (WiFi.status() == WL_CONNECTED || ETH.localIP()) {
int pingResult = Ping.ping("8.8.8.8"); // Use Google's public DNS server as a test IP
if (pingResult >= 0) {
LOG(DEBUG, "Network connection established");
break;
} else {
LOG(DEBUG, "Network not ready, retrying...");
}
} else {
LOG(DEBUG, "No WiFi or Ethernet connection, retrying...");
}
delay(1000); // Delay to prevent rapid retry
}
xTaskCreate(display_task, "DisplayTask", 10000, NULL, 1, NULL);
}