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

Merge pull request 'logger-rework' (#1) from logger-rework into main
Some checks failed
Test compiling project / test (push) Has been cancelled
Details

Browse Source 
Reviewed-on: https://gitea.maiertobi.de/tobimai/waterlevel-software/pulls/1
This commit was merged in pull request #1.
This commit is contained in:
Tobias Maier
2025-03-23 18:14:19 +01:00
parent 374b23d99a abbb8d918b
commit 0cc2638db2
16 changed files with 247 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.vscode/settings.json vendored
View File

@@ -1,6 +1,7 @@
{
"files.associations": {
"iostream": "cpp",
"random": "cpp"
"random": "cpp",
"vector": "cpp"
}
}

10
data/update_progress.html
View File

@@ -18,13 +18,13 @@
</body>
<script>
const ws = new WebSocket('ws://' + window.location.host + '/ws');
const webSocket = new WebSocket('webSocket://' + window.location.host + '/webSocket');
ws.onopen = function() {
webSocket.onopen = function() {
console.log('WebSocket connection opened.');
};
ws.onmessage = function(event) {
webSocket.onmessage = function(event) {
console.log('Progress:', event.data);
// Update the progress bar
let progress = parseInt(event.data);
@@ -48,11 +48,11 @@
};
ws.onerror = function(error) {
webSocket.onerror = function(error) {
console.error('WebSocket error:', error);
};
ws.onclose = function() {
webSocket.onclose = function() {
console.log('WebSocket connection closed.');
};
</script>

6
documentation/old.md
View File

@@ -17,7 +17,7 @@ void listNetworkInterfaces() {
}
void setEthernetAsDefault() {
Log.verbose("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
logger.log(0, DEBUG, "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
listNetworkInterfaces();
// Attempt to locate the Ethernet network interface.
// (The name may vary—on some systems it might be "eth0")
@@ -31,8 +31,8 @@ void setEthernetAsDefault() {
struct netif *eth_netif2 = netif_find("ETH_DEF");
if (netif) {
netif_set_default(eth_netif2);
Log.verbose("Ethernet set as default network interface.");
logger.log(0, DEBUG, "Ethernet set as default network interface.");
} else {
Log.verbose("Could not find Ethernet netif.");
logger.log(0, DEBUG, "Could not find Ethernet netif.");
}
}

50
lib/INA233/INA233.cpp
View File

@@ -23,6 +23,31 @@ uint16_t get_word(uint8_t address, uint8_t reg) {
return (data[1] << 8) | data[0];
}
String INA233::get_device_model() {
char data[7]; // Array size includes space for the null terminator
// Request data from the PMBus device
Wire.beginTransmission(INA233::_address);
Wire.write(0x9A); // Command to read the manufacturer ID
Wire.endTransmission();
Wire.requestFrom(INA233::_address, 7);
if (Wire.available() == 7) {
uint8_t i = Wire.read();
data[0] = Wire.read();
data[1] = Wire.read();
data[2] = Wire.read();
data[3] = Wire.read();
data[4] = Wire.read();
data[5] = Wire.read();
data[6] = '\0'; // Null-terminate the string
} else {
return String("");
}
return String(data);
}
void sendWord(uint8_t deviceAddress, uint8_t registerAddress, uint16_t value) {
Wire.beginTransmission(deviceAddress);
@@ -32,6 +57,13 @@ void sendWord(uint8_t deviceAddress, uint8_t registerAddress, uint16_t value) {
Wire.endTransmission();
}
void sendByte(uint8_t deviceAddress, uint8_t registerAddress, uint8_t value) {
Wire.beginTransmission(deviceAddress);
Wire.write(registerAddress); // Send the register address
Wire.write((uint8_t)value); // Send the low byte first
Wire.endTransmission();
}
INA233::INA233(const uint8_t address, TwoWire *wire)
{
_address = address;
@@ -84,8 +116,18 @@ float INA233::getBusVoltage() {
}
float INA233::getShuntVoltage() {
uint16_t rawVoltage = get_word(INA233::_address, REGISTER_READ_VSHUNT);
float voltage = rawVoltage * pow(10,-4);
int16_t rawVoltage = get_word(INA233::_address, REGISTER_READ_VSHUNT); // Read raw voltage (16-bit register)
// Convert from two's complement to an integer value
// If the MSB (most significant bit) is set, the number is negative
if (rawVoltage & 0x8000) { // Check if MSB (bit 15) is set
rawVoltage = rawVoltage - 0x10000; // Convert two's complement negative number
}
// Convert value according to the datasheet
// LSB: 2.5 μV per bit -> Multiply by 2.5e-6 to convert to volts
float voltage = rawVoltage * 2.5e-6;
return voltage;
}
@@ -149,4 +191,8 @@ void INA233::setShuntVoltageConversionTime(ConversionTime conversion_time) {
uint16_t INA233::getConfigRegister() {
return get_word(INA233::_address, REGISTER_CONFIGURATION);
}
void INA233::reset() {
sendByte(INA233::_address, 0x12, 0x00);
}

26
lib/INA233/INA233.h
View File

@@ -7,6 +7,7 @@
#define REGISTER_READ_VIN 0x88
#define REGISTER_READ_VSHUNT 0xD1
#define REGISTER_CONFIGURATION 0xD0
#define REGISTER_READ_IIN 0x89
enum AveragingMode {
averages_1 = B000,
@@ -32,20 +33,23 @@ enum ConversionTime {
class INA233{
public:
INA233(uint8_t addr, TwoWire *wire = &Wire);
bool begin(const uint8_t sda, const uint8_t scl);
String get_device_model();
INA233(uint8_t addr, TwoWire* wire = &Wire);
bool begin(const uint8_t sda, const uint8_t scl);
float getBusVoltage(void);
float getShuntVoltage_mV(void);
float getShuntVoltage(void);
float getBusVoltage(void);
float getShuntVoltage_mV(void);
float getShuntVoltage(void);
void setAveragingMode(AveragingMode);
void setBusVoltageConversionTime(ConversionTime);
void setShuntVoltageConversionTime(ConversionTime);
uint16_t getConfigRegister();
void setAveragingMode(AveragingMode);
void setBusVoltageConversionTime(ConversionTime);
void setShuntVoltageConversionTime(ConversionTime);
bool isConnected(void);
uint16_t getConfigRegister();
void reset();
bool isConnected(void);
private:
float _current_LSB;

42
lib/fetchOTA/fetchOTA.cpp
View File

@@ -6,7 +6,7 @@
#include <ArduinoJson.h>
#include <HTTPClient.h>
#include <vector>
#include <ArduinoLog.h>
#include <Elog.h>
#include <HTTPUpdate.h>
@@ -22,14 +22,14 @@ Firmware OTA::getLatestVersionOnServer() {
HTTPClient http;
http.begin(_serverUrl);
int httpCode = http.GET();
Log.verbose("HTTP Code: %d", httpCode);
logger.log(0, DEBUG, "HTTP Code: %d", httpCode);
if (httpCode != 200) {
return createErrorResponse("HTTP GET request failed with code " + String(httpCode));
}
String payload = http.getString();
Log.verbose("Payload: %s", payload.c_str());
logger.log(0, DEBUG, "Payload: %s", payload.c_str());
DynamicJsonDocument doc(4096);
DeserializationError error = deserializeJson(doc, payload);
@@ -54,7 +54,7 @@ Firmware OTA::getLatestVersionOnServer() {
deviceConfig
});
} else {
Log.verbose("Configuration %s does not match current device configuration %s", deviceConfig.c_str(), _current_device_configuration.c_str());
logger.log(0, DEBUG, "Configuration %s does not match current device configuration %s", deviceConfig.c_str(), _current_device_configuration.c_str());
}
}
}
@@ -67,7 +67,7 @@ Firmware OTA::getLatestVersionOnServer() {
Configuration latest = getLatestConfiguration(configs.data(), configs.size());
if (!isVersionNewer(_currentVersion, latest.version)) {
Log.verbose("No newer version found. Server version: %d.%d.%d", latest.version.major, latest.version.minor, latest.version.patch);
logger.log(0, DEBUG, "No newer version found. Server version: %d.%d.%d", latest.version.major, latest.version.minor, latest.version.patch);
}
return Firmware{
@@ -88,79 +88,79 @@ Firmware OTA::createErrorResponse(const String& errorMsg) {
}
void run_ota_update(String url, std::function<void()> callback_started, std::function<void()> callback_finished, std::function<void(int, int)> callback_progress, std::function<void(int)> callback_error) {
Log.verbose("Starting OTA upgrade");
logger.log(0, DEBUG, "Starting OTA upgrade");
HTTPUpdate httpUpdate;
httpUpdate.onStart(callback_started);
httpUpdate.onEnd(callback_finished);
httpUpdate.onProgress(callback_progress);
httpUpdate.onError(callback_error);
Log.verbose("Defined callbacks, Starting update now");
logger.log(0, DEBUG, "Defined callbacks, Starting update now");
t_httpUpdate_return ret;
if (url.startsWith("https")) {
Log.verbose("HTTPS URL");
logger.log(0, DEBUG, "HTTPS URL");
WiFiClientSecure client;
client.setInsecure();
ret = httpUpdate.update(client, url);
} else if (url.startsWith("http")) {
Log.verbose("HTTP URL");
logger.log(0, DEBUG, "HTTP URL");
WiFiClient client;
ret = httpUpdate.update(client, url);
} else {
Log.error("URL is not valid: \n%s", url.c_str());
logger.log(0, ERROR, "URL is not valid: \n%s", url.c_str());
}
switch (ret) {
case HTTP_UPDATE_FAILED:
Log.error("HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
logger.log(0, ERROR, "HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
break;
case HTTP_UPDATE_NO_UPDATES:
Log.error("HTTP_UPDATE_NO_UPDATES");
logger.log(0, ERROR, "HTTP_UPDATE_NO_UPDATES");
break;
case HTTP_UPDATE_OK:
Log.verbose("Update done");
logger.log(0, DEBUG, "Update done");
break;
}
}
void run_ota_spiffs_update(String url, std::function<void()> callback_started, std::function<void()> callback_finished, std::function<void(int, int)> callback_progress, std::function<void(int)> callback_error) {
Log.verbose("Starting OTA SPIFFS upgrade");
logger.log(0, DEBUG, "Starting OTA SPIFFS upgrade");
HTTPUpdate httpUpdate;
httpUpdate.onStart(callback_started);
httpUpdate.onEnd(callback_finished);
httpUpdate.onProgress(callback_progress);
httpUpdate.onError(callback_error);
Log.verbose("Defined callbacks, Starting update now");
logger.log(0, DEBUG, "Defined callbacks, Starting update now");
t_httpUpdate_return ret;
if (url.startsWith("https")) {
Log.verbose("HTTPS URL");
logger.log(0, DEBUG, "HTTPS URL");
WiFiClientSecure client;
client.setInsecure();
ret = httpUpdate.updateSpiffs(client, url);
} else if (url.startsWith("http")) {
Log.verbose("HTTP URL");
logger.log(0, DEBUG, "HTTP URL");
WiFiClient client;
ret = httpUpdate.updateSpiffs(client, url);
} else {
Log.error("URL is not valid: \n%s", url.c_str());
logger.log(0, ERROR, "URL is not valid: \n%s", url.c_str());
}
switch (ret) {
case HTTP_UPDATE_FAILED:
Log.error("HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
logger.log(0, ERROR, "HTTP_UPDATE_FAILED Error (%d): %s\n", httpUpdate.getLastError(), httpUpdate.getLastErrorString().c_str());
break;
case HTTP_UPDATE_NO_UPDATES:
Log.error("HTTP_UPDATE_NO_UPDATES");
logger.log(0, ERROR, "HTTP_UPDATE_NO_UPDATES");
break;
case HTTP_UPDATE_OK:
Log.verbose("SPIFFS Update done");
logger.log(0, DEBUG, "SPIFFS Update done");
break;
}
}

11
platformio.ini
View File

@@ -19,14 +19,14 @@ monitor_speed = 115200
lib_deps =
ottowinter/ESPAsyncWebServer-esphome@^3.3.0
bblanchon/ArduinoJson@^6.21.3
jsc/ArduinoLog
fetchOTA
INA322
INA233
ESP32Ping
https://github.com/tobimai/elog.git#fix-syslog
board_build.partitions = default.csv
upload_protocol = espota
upload_port = 192.168.5.180
build_flags = -Wall -Wextra
upload_port = 10.1.60.43
build_flags = -Wall -Wextra -DLOGGING_SPIFFS_DISABLE -DLOGGING_SD_DISABLE
[env:ESP32_INA226]
platform = espressif32
@@ -39,10 +39,11 @@ lib_deps =
bblanchon/ArduinoJson@^6.21.3
jsc/ArduinoLog
ESP32Ping
https://github.com/tobimai/elog.git#fix-syslog
board_build.partitions = default.csv
upload_protocol = espota
upload_port = 192.168.4.18
build_flags = -Wall -Wextra -DUSE_INA226
build_flags = -Wall -Wextra -DUSE_INA226 -DLOGGING_SPIFFS_DISABLE -DLOGGING_SD_DISABLE
[env:native]
platform = native

9
src/external_interfacing/leds.cpp
View File

@@ -1,7 +1,8 @@
#include "leds.h"
#include <Arduino.h>
#include <ArduinoLog.h>
#include <Elog.h>
#include "../tools/tools.h"
#include <tools/log.h>
extern ActiveErrors active_errors;
extern WaterData water_data;
@@ -72,20 +73,22 @@ void display_task(void* parameter)
// We have no error, refresh status display and wait half a second
display_percentage(water_data.percentage);
} else {
Log.verbose("Error detected");
// We have an error, display error code for 3 seconds and then water level for 3 seconds
if (active_errors.voltage_low) {
display_error_code(1);
LOG(WARNING, "Sensor Error - Voltage low");
delay(3000);
} else if (active_errors.voltage_high) {
display_error_code(2);
LOG(WARNING, "Sensor Error - Voltage High");
delay(3000);
} else if (active_errors.current_low) {
display_error_code(3);
LOG(WARNING, "Sensor Error - Current low");
delay(3000);
} else if (active_errors.current_high) {
display_error_code(4);
LOG(WARNING, "Sensor Error - Current high");
delay(3000);
} else {
delay(3000);

2
src/global_data/defines.h
View File

@@ -7,7 +7,7 @@
#define water_level_min_key "water_level_min"
#define water_level_max_key "water_level_max"
#define water_volume_key "water_volume"
#define current_software_version Version{1, 0, 1}
#define current_software_version Version{1, 0, 0}
#define REQUIRED_SPIFFS_VERSION Version{8, 0, 0}
#define RESISTOR_VALUE 4

124
src/main.cpp
View File

@@ -8,7 +8,7 @@
#include "AsyncJson.h"
#include <ArduinoJson.h>
#include <ArduinoLog.h>
#include <Elog.h>
#include <ArduinoOTA.h>
@@ -25,7 +25,10 @@
#include "networking/responses.h"
#include <fetchOTA.h>
#include <ESP32Ping.h>
#include "time.h"
#include "tools/log.h"
#define MYLOG 0
Preferences prefs;
@@ -40,19 +43,16 @@ extern "C" int rom_phy_get_vdd33();
Version current_spiffs_version;
AsyncWebServer server(80);
AsyncWebSocket ws("/ws");
AsyncWebSocket webSocket("/webSocket");
#define FORMAT_LITTLEFS_IF_FAILED true
void setup()
{
{
logger.registerSerial(MYLOG, DEBUG, "tst");
prefs.begin("waterlevel", false);
Serial.begin(115200);
Log.begin(LOG_LEVEL_VERBOSE, &Serial);
Log.setSuffix(printSuffix);
Log.setPrefix(print_prefix);
Log.verbose("Init LEDs");
LOG(DEBUG, "Init LEDs");
pinMode(LED_1, OUTPUT);
pinMode(LED_2, OUTPUT);
pinMode(LED_3, OUTPUT);
@@ -64,7 +64,7 @@ void setup()
display_error_code(17);
init_sensor();
Log.verbose("Beginning SPIFFS");
LOG(DEBUG, "Beginning SPIFFS");
SPIFFS.begin(true);
// Read the current SPIFFS version from the versions file on the spiffs
@@ -73,21 +73,21 @@ void setup()
Serial.println("Failed to open version file for reading");
} else {
String version = file.readStringUntil('\n');
Log.verbose("Version: %s", version);
LOG(DEBUG, "Version: %s", version);
current_spiffs_version = parseVersion(version.c_str());
Log.verbose("Current SPIFFS Version: %d.%d.%d", current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch);
LOG(DEBUG, "Current SPIFFS Version: %d.%d.%d", current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch);
}
Log.verbose("SPIFFS initialized");
LOG(DEBUG, "SPIFFS initialized");
display_error_code(19);
Log.verbose("Begin INA");
LOG(DEBUG, "Begin INA");
display_error_code(22);
/////////////////////////////// ROUTES ///////////////////////////////
Log.verbose("Route Setup");
LOG(DEBUG, "Route Setup");
// Normal HTML stuff
server.on("/", HTTP_GET, [](AsyncWebServerRequest* request) { request->send(SPIFFS, "/status.html", "text/html", false, processor); });
@@ -106,7 +106,7 @@ void setup()
// For settings SSID
if (request->hasParam(ssid_key, true) && request->hasParam(wifi_password_key, true)) {
Log.verbose("Updating SSID config");
LOG(DEBUG, "Updating SSID config");
AsyncWebParameter* ssid_param = request->getParam(ssid_key, true);
AsyncWebParameter* password_param = request->getParam(wifi_password_key, true);
prefs.putString(ssid_key, ssid_param->value().c_str());
@@ -122,7 +122,7 @@ void setup()
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.verbose("Updating Sensor config");
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);
@@ -144,24 +144,24 @@ void setup()
// Convert the C string to a float using strtod
float value = strtod(paramCStr, &endPtr);
Log.verbose("range_float:%D:", range_float);
LOG(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.verbose("range_float_after:%D:", prefs.getFloat(level_sensor_range_key, -1.0));
LOG(DEBUG, "range_float_after:%D:", prefs.getFloat(level_sensor_range_key, -1.0));
} else {
Log.verbose("!!!! FAIL lo");
LOG(DEBUG, "!!!! FAIL lo");
for (int i = 0; i < params; i++) {
AsyncWebParameter* p = request->getParam(i);
if (p->isFile()) { // p->isPost() is also true
Log.verbose("POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
LOG(DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
} else if (p->isPost()) {
Log.verbose("POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
LOG(DEBUG, "POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
} else {
Log.verbose("GET[%s]: %s\n", p->name().c_str(), p->value().c_str());
LOG(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
@@ -171,8 +171,8 @@ void setup()
setup_api_endpoints();
display_error_code(23);
ws.onEvent(onWsEvent);
server.addHandler(&ws);
webSocket.onEvent(onWsEvent);
server.addHandler(&webSocket);
@@ -181,7 +181,7 @@ void setup()
display_error_code(24);
Log.verbose("OTA Setup");
LOG(DEBUG, "OTA Setup");
ArduinoOTA
.onStart([]() {
String type;
@@ -191,42 +191,80 @@ void setup()
type = "filesystem";
// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
Log.verbose("Start updating %s", type); })
.onEnd([]() { Log.verbose("\nEnd"); })
LOG(DEBUG, "Start updating %s", type); })
.onEnd([]() { LOG(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.verbose("Auth Failed");
else if (error == OTA_BEGIN_ERROR) Log.verbose("Begin Failed");
else if (error == OTA_CONNECT_ERROR) Log.verbose("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) Log.verbose("Receive Failed");
else if (error == OTA_END_ERROR) Log.verbose("End Failed"); });
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"); });
display_error_code(26);
digitalWrite(LED_RED, 0);
// Starting bootup sequence
xTaskCreate(ethernet_task, "EthernetTask", 4096, NULL, 1, NULL);
delay(1000);
bool started = false;
// 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");
xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 8, NULL, 1, NULL);
started = true;
}
xTaskCreate(wifi_task, "WiFiTask", 10000, NULL, 1, NULL);
if (!started) {
} else {
LOG(DEBUG, "Ethernet not connected, starting update checker and WiFi Task");
xTaskCreate(wifi_task, "WiFiTask", 10000, NULL, 1, NULL);
xTaskCreate(check_update_task, "CheckUpdateTask", 1024 * 8, NULL, 1, NULL);
delay(2000);
}
LOG(DEBUG, "Getting time now");
// Configure time to UTC
configTime(0, 0, "pool.ntp.org");
// Wait until a valid time is obtained (time > 8 hours in seconds)
time_t now = time(NULL);
struct tm timeinfo;
int retry = 0;
while (now < 8 * 3600 && retry < 10) {
if(!getLocalTime(&timeinfo)){
Serial.println("Failed to obtain time");
}
Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
retry++;
}
getLocalTime(&timeinfo);
// 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: ");
} else {
LOG(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.verbose("Starting webserver");
LOG(DEBUG, "Starting webserver");
server.begin();
ArduinoOTA.begin();
display_error_code(25);
xTaskCreate(display_task, "DisplayTask", 10000, NULL, 1, NULL);
xTaskCreate(read_sensor_task, "ReadSensorTask", 2048, 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
@@ -234,13 +272,13 @@ void setup()
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.verbose("Network connection established");
LOG(DEBUG, "Network connection established");
break;
} else {
Log.verbose("Network not ready, retrying...");
LOG(DEBUG, "Network not ready, retrying...");
}
} else {
Log.verbose("No WiFi or Ethernet connection, retrying...");
LOG(DEBUG, "No WiFi or Ethernet connection, retrying...");
}
delay(1000); // Delay to prevent rapid retry
}

2
src/networking/json_builder.cpp
View File

@@ -1,5 +1,5 @@
#include "json_builder.h"
#include <ArduinoLog.h>
#include <Elog.h>
extern WaterData water_data;
extern DeviceTelemetry telemetry;

19
src/networking/networking.cpp
View File

@@ -1,9 +1,10 @@
#include <ArduinoLog.h>
#include <Elog.h>
#include <ETH.h>
#include <WiFi.h>
#include "../global_data/defines.h"
#include <Preferences.h>
#include "../global_data/global_data.h"
#include <tools/log.h>
int64_t mac_address = ESP.getEfuseMac();
uint8_t failed_connection_attempts = 0;
@@ -34,21 +35,21 @@ const char * get_hostname(HostnameType host_type) {
void wifi_task(void* parameter)
{
Log.verbose("Starting WiFi Task");
LOG(DEBUG, "Starting WiFi Task");
WiFi.setHostname(get_hostname(Wireless));
while (true) {
if (prefs.getString(ssid_key, "") == "" || failed_connection_attempts > 5) {
wifi_data.link = false;
if (failed_connection_attempts > 5) {
Log.verbose("Failed to connecto to currently saved SSID, starting SoftAP");
LOG(DEBUG, "Failed to connecto to currently saved SSID, starting SoftAP");
} else {
Log.verbose("No SSID saved, starting SoftAP");
LOG(DEBUG, "No SSID saved, starting SoftAP");
}
String ap_ssid = get_hostname(Wireless);
WiFi.softAP(ap_ssid, "");
Log.verbose("[WIFI_TASK] Waiting for SSID now...");
LOG(DEBUG, "[WIFI_TASK] Waiting for SSID now...");
String old_ssid = prefs.getString(ssid_key, "xxx");
while (prefs.getString(ssid_key, "") == "" || prefs.getString(ssid_key, "") == old_ssid) {
@@ -64,11 +65,11 @@ void wifi_task(void* parameter)
wifi_data.network_name = WiFi.SSID();
wifi_data.ip_address = WiFi.localIP().toString();
// Log.verbose("RSSI: %F, IP Address, %p, SSID: %s", float(WiFi.RSSI()), WiFi.localIP(), prefs.getString(ssid_key, "NOSSID"));
// LOG(DEBUG, "RSSI: %F, IP Address, %p, SSID: %s", float(WiFi.RSSI()), WiFi.localIP(), prefs.getString(ssid_key, "NOSSID"));
// Serial.println(WiFi.channel());
delay(5000);
} else {
Log.verbose("Connecting to %s using password %s", prefs.getString(ssid_key, ""), prefs.getString(wifi_password_key, ""));
LOG(DEBUG, "Connecting to %s using password %s", prefs.getString(ssid_key, ""), prefs.getString(wifi_password_key, ""));
WiFi.mode(WIFI_STA);
WiFi.begin(prefs.getString(ssid_key, ""), prefs.getString(wifi_password_key, ""));
failed_connection_attempts++;
@@ -80,14 +81,14 @@ void wifi_task(void* parameter)
void ethernet_task(void* parameter)
{
Log.verbose("Connecting Ethernet");
LOG(DEBUG, "Connecting Ethernet");
ETH.begin(0, 17, 23, 18);
ETH.setHostname(get_hostname(Ethernet));
while (true) {
ethernet_data.link = ETH.linkUp();
ethernet_data.rssi = ETH.linkSpeed();
ethernet_data.ip_address = ETH.localIP().toString();
// Log.verbose("Ethernet RSSI: %F, IP Address, %s, LINK: %s", float(ethernet_data.rssi), ethernet_data.ip_address, String(ethernet_data.link));
// LOG(DEBUG, "Ethernet RSSI: %F, IP Address, %s, LINK: %s", float(ethernet_data.rssi), ethernet_data.ip_address, String(ethernet_data.link));
delay(60 * 1000);
}
}

2
src/networking/responses.cpp
View File

@@ -4,7 +4,7 @@
#include <ESPAsyncWebServer.h>
#include "AsyncJson.h"
#include <ArduinoJson.h>
#include <ArduinoLog.h>
#include <Elog.h>
#include "json_builder.h"
#include "../tools/tools.h"
#include <SPIFFS.h>

25
src/sensor/sensor.cpp
View File

@@ -1,6 +1,6 @@
#include "../global_data/defines.h"
#include <Preferences.h>
#include <ArduinoLog.h>
#include <Elog.h>
#include "Wire.h"
#include "../global_data/global_data.h"
@@ -12,6 +12,10 @@ INA226 ina_sensor(0x40);
#include <INA233.h>
INA233 ina_sensor(0x40);
#endif
#include <tools/log.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
extern Preferences prefs;
extern WaterData water_data;
@@ -29,6 +33,7 @@ void init_sensor(){
ina_sensor.setShuntVoltageConversionTime(7);
ina_sensor.setAverage(4);
#else
ina_sensor.reset();
ina_sensor.setShuntVoltageConversionTime(conversion_time_8244uS);
ina_sensor.setBusVoltageConversionTime(conversion_time_8244uS);
ina_sensor.setAveragingMode(averages_128);
@@ -39,10 +44,16 @@ void read_sensor_task(void* parameter)
{
while (true) {
// Get Values from sensor
#ifndef USE_INA226
String chip_id = ina_sensor.get_device_model();
LOG(DEBUG, "Chip Model: %s", chip_id.c_str());
#endif
float bus_voltage = ina_sensor.getBusVoltage();
float shunt_voltage = ina_sensor.getShuntVoltage_mV() - zero_value;
LOG(DEBUG, "RAW Shunt voltage: %F mV", ina_sensor.getShuntVoltage_mV());
float shunt_current = shunt_voltage / RESISTOR_VALUE;
// Get values from storage
@@ -61,8 +72,8 @@ void read_sensor_task(void* parameter)
float min_water_level_mA = 4 + min_water_level_mA_over_zero;
float max_water_level_mA = 4 + max_water_level_mA_over_zero;
// Log.verbose("max_water_level_mA: %F", max_water_level_mA);
// Log.verbose("min_water_level_mA_over_zero: %F", min_water_level_mA_over_zero);
LOG(DEBUG, "max_water_level_mA: %F", max_water_level_mA);
LOG(DEBUG, "min_water_level_mA_over_zero: %F", min_water_level_mA_over_zero);
// Current over the 0 level of the water
float shunt_current_over_zero = shunt_current - min_water_level_mA;
@@ -82,10 +93,10 @@ void read_sensor_task(void* parameter)
active_errors.current_high = shunt_current > 20.2;
active_errors.voltage_low = bus_voltage < 23;
active_errors.voltage_high = bus_voltage > 25;
// Log.verbose("Shunt current: %F", shunt_current);
// Log.verbose("Shunt voltage: %F", shunt_voltage);
// Log.verbose("Bus voltage: %F", bus_voltage);
// Log.verbose("cm_over_zero: %F", cm_over_zero);
LOG(DEBUG, "Shunt current: %F", shunt_current);
LOG(DEBUG, "Shunt voltage: %F", shunt_voltage);
LOG(DEBUG, "Bus voltage: %F", bus_voltage);
LOG(DEBUG, "cm_over_zero: %F", cm_over_zero);
shunt_data.bus_voltage = bus_voltage;
shunt_data.shunt_voltage = shunt_voltage;

11
src/tools/log.h Normal file
View File

@@ -0,0 +1,11 @@
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#define LOG(LEVEL, FMT, ...) \
do { \
logger.log(0, LEVEL, "[Core: %i][Task: %s][%s] " FMT, \
xPortGetCoreID(), \
pcTaskGetName(xTaskGetCurrentTaskHandle()), \
__FUNCTION__, \
##__VA_ARGS__); \
} while (0)

49
src/tools/tools.cpp
View File

@@ -1,31 +1,18 @@
#include <Arduino.h>
#include "tools.h"
#include <ArduinoLog.h>
#include <Elog.h>
#include "../global_data/defines.h"
#include <Preferences.h>
#include <fetchOTA.h>
#include <AsyncWebSocket.h>
#include "log.h"
extern Preferences prefs;
extern OTAStatus ota_status;
extern AsyncWebSocket ws;
extern AsyncWebSocket webSocket;
extern Version current_spiffs_version;
void printSuffix(Print* _logOutput, int logLevel)
{
_logOutput->print(CR);
}
void print_prefix(Print* _logOutput, int logLevel)
{
_logOutput->print("WATERMETER - TESTLOL - C");
_logOutput->print(xPortGetCoreID());
_logOutput->print(" - ");
_logOutput->print(pcTaskGetName(xTaskGetCurrentTaskHandle()));
_logOutput->print(" - ");
}
bool is_error(ActiveErrors active_errors) {
return active_errors.current_high || active_errors.current_low || active_errors.level_high || active_errors.level_low || active_errors.voltage_high || active_errors.voltage_low;
}
@@ -49,28 +36,28 @@ String processor(const String& var)
// OTA Callbacks
void update_started() {
Log.verbose("OTA Update started");
LOG(DEBUG, "OTA Update started");
ota_status.update_progress = 0;
}
void update_finished() {
Log.verbose("OTA Update finished");
LOG(DEBUG, "OTA Update finished");
ota_status.update_progress = -1;
ws.textAll(String(-1).c_str());
webSocket.textAll(String(-1).c_str());
}
void update_progress(int cur, int total) {
ota_status.update_progress = 0;
if (cur != 0 ) {
ota_status.update_progress = int(float(cur)/float(total)*100);
Log.verbose("OTA Update progress: %d/%d, %i", cur, total, ota_status.update_progress);
LOG(DEBUG, "OTA Update progress: %d/%d, %i", cur, total, ota_status.update_progress);
}
ws.textAll(String(ota_status.update_progress).c_str());
Log.verbose("OTA Update progress: %d/%d", cur, total);
webSocket.textAll(String(ota_status.update_progress).c_str());
LOG(DEBUG, "OTA Update progress: %d/%d", cur, total);
}
void update_error(int err) {
Log.error("OTA Update error: %d", err);
LOG(ERROR, "OTA Update error: %d", err);
ota_status.update_progress = -2;
}
@@ -89,20 +76,20 @@ void check_update_task(void* parameter) {
// If there is a SPIFSS update it will be ran automatically, as SPIFFS is necessary for the firmware to run
Firmware latest_spiff_version = spiffs_fs.getLatestVersionOnServer();
Log.verbose("Required SPIFFS Version: %d.%d.%d; Current SPIFFS version: %d.%d.%d; Server SPIFFS Version: %d.%d.%d", REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch, current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch, latest_spiff_version.version.major, latest_spiff_version.version.minor, latest_spiff_version.version.patch);
LOG(DEBUG, "Required SPIFFS Version: %d.%d.%d; Current SPIFFS version: %d.%d.%d; Server SPIFFS Version: %d.%d.%d", REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch, current_spiffs_version.major, current_spiffs_version.minor, current_spiffs_version.patch, latest_spiff_version.version.major, latest_spiff_version.version.minor, latest_spiff_version.version.patch);
if (latest_spiff_version.valid) {
if (isVersionNewer(current_spiffs_version, REQUIRED_SPIFFS_VERSION)) {
// If Required SPIFFS version is newer than current version, update
Log.verbose("New SPIFFS version, running update now");
LOG(DEBUG, "New SPIFFS version, running update now");
run_ota_spiffs_update(latest_spiff_version.url, update_started, update_finished, update_progress, update_error);
// Reboot just to be safe
ESP.restart();
} else if (isVersionNewer(REQUIRED_SPIFFS_VERSION, latest_spiff_version.version)) {
// If Server has new SPIFFS version but it's not required
Log.verbose("New SPIFFS version available: %d.%d.%d, current version: %d.%d.%d but not necessary to update", latest_spiff_version.version.major, latest_spiff_version.version.minor, latest_spiff_version.version.patch, REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch);
LOG(DEBUG, "New SPIFFS version available: %d.%d.%d, current version: %d.%d.%d but not necessary to update", latest_spiff_version.version.major, latest_spiff_version.version.minor, latest_spiff_version.version.patch, REQUIRED_SPIFFS_VERSION.major, REQUIRED_SPIFFS_VERSION.minor, REQUIRED_SPIFFS_VERSION.patch);
} else {
Log.verbose("No new SPIFFS version available");
LOG(DEBUG, "No new SPIFFS version available");
}
}
@@ -110,11 +97,11 @@ void check_update_task(void* parameter) {
while (true) {
Firmware fw = ota.getLatestVersionOnServer();
if (fw.valid) {
Log.verbose("New firmware available: %d.%d.%d, current version: %d.%d.%d", fw.version.major, fw.version.minor, fw.version.patch, current_software_version.major, current_software_version.minor, current_software_version.patch);
LOG(DEBUG, "New firmware available: %d.%d.%d, current version: %d.%d.%d", fw.version.major, fw.version.minor, fw.version.patch, current_software_version.major, current_software_version.minor, current_software_version.patch);
ota_status.latest_version = fw.version;
ota_status.update_url = fw.url;
if (isVersionNewer(current_software_version, fw.version)) {
Log.verbose("Remote version is newer than current version");
LOG(DEBUG, "Remote version is newer than current version");
ota_status.update_available = true;
} else {
ota_status.update_available = false;
@@ -125,7 +112,7 @@ void check_update_task(void* parameter) {
ota_status.update_available = false;
}
Log.verbose("No new firmware available");
LOG(DEBUG, "No new firmware available");
}
delay(1000 * 60 * 1);
}
@@ -135,7 +122,7 @@ void check_update_task(void* parameter) {
void run_ota_update_task(void* parameter) {
TaskArgs_t *args = (TaskArgs_t *) parameter;
Log.verbose("Running OTA upgrade now with URL: %s", args->ota_status.update_url.c_str());
LOG(DEBUG, "Running OTA upgrade now with URL: %s", args->ota_status.update_url.c_str());
run_ota_update(args->ota_status.update_url, update_started, update_finished, update_progress, update_error);
vTaskDelete(NULL);
}