jeans/openHASP
jeans/openHASP
1
0
Fork 0
mirror of https://github.com/HASwitchPlate/openHASP.git synced 2025-07-24 11:46:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Overall log level and log macros

Browse Source
This commit is contained in:
fvanroie 2021-02-09 21:26:03 +01:00
parent 109991cd01
commit 3c1366ee80
31 changed files with 557 additions and 441 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
include/hasp_macro.h Normal file
View File

@ -0,0 +1,65 @@
#ifndef HASP_MACRO_H
#define HASP_MACRO_H
#if HASP_LOG_LEVEL > LOG_LEVEL_FATAL
#define LOG_FATAL(...) \
Log.fatal(__VA_ARGS__); \
while(true) { \
}
#else
#define LOG_FATAL(...) \
do { \
} while(0)
#endif
#if HASP_LOG_LEVEL > LOG_LEVEL_ALERT
#define LOG_ALERT(...) Log.alert(__VA_ARGS__)
#else
#define LOG_ALERT(...)
#endif
#if HASP_LOG_LEVEL > LOG_LEVEL_CRITICAL
#define LOG_CRITICAL(...) Log.critical(__VA_ARGS__)
#else
#define LOG_CRITICAL(...)
#endif
#if HASP_LOG_LEVEL > LOG_LEVEL_ERROR
#define LOG_ERROR(...) Log.error(__VA_ARGS__)
#else
#define LOG_ERROR(...)
#endif
#if HASP_LOG_LEVEL > LOG_LEVEL_WARNING
#define LOG_WARNING(...) Log.warning(__VA_ARGS__)
#else
#define LOG_WARNING(...)
#endif
#if HASP_LOG_LEVEL > LOG_LEVEL_INFO
#define LOG_INFO(...) Log.notice(__VA_ARGS__)
#else
#define LOG_INFO(...)
#endif
#if HASP_LOG_LEVEL > LOG_LEVEL_TRACE
#define LOG_TRACE(...) Log.trace(__VA_ARGS__)
#else
#define LOG_TRACE(...)
#endif
#if HASP_LOG_LEVEL > LOG_LEVEL_VERBOSE
#define LOG_VERBOSE(...) Log.verbose(__VA_ARGS__)
#else
#define LOG_VERBOSE(...)
#endif
#if HASP_LOG_LEVEL > LOG_LEVEL_DEBUG
#define LOG_DEBUG(...) Log.debug(__VA_ARGS__)
#else
#define LOG_DEBUG(...)
#endif
#define LOG_OUTPUT(...) Log.output(...)
#endif

2
lib/ArduinoLog/ArduinoLog.cpp
View File

@ -62,7 +62,7 @@ void Logging::unregisterOutput(uint8_t slot)
void Logging::setLevel(uint8_t slot, int level)
{
#ifndef DISABLE_LOGGING
_level[slot] = constrain(level, LOG_LEVEL_SILENT, LOG_LEVEL_VERBOSE);
_level[slot] = constrain(level, LOG_LEVEL_SILENT, LOG_LEVEL_OUTPUT);
#endif
}

49
lib/ArduinoLog/ArduinoLog.h
View File

@ -17,9 +17,9 @@ Licensed under the MIT License <http://opensource.org/licenses/MIT>.
#include <inttypes.h>
#include <stdarg.h>
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#include "Arduino.h"
#else
#include "WProgram.h"
#include "WProgram.h"
#endif
//#include "StringStream.h"
typedef void (*printfunction)(uint8_t tag, int level, Print *);
@ -39,10 +39,11 @@ typedef void (*printfunction)(uint8_t tag, int level, Print *);
#define LOG_LEVEL_ERROR 3
#define LOG_LEVEL_WARNING 4
#define LOG_LEVEL_NOTICE 5
#define LOG_LEVEL_INFO 6
#define LOG_LEVEL_INFO 5
#define LOG_LEVEL_TRACE 6
#define LOG_LEVEL_VERBOSE 7
#define LOG_LEVEL_DEBUG 7
#define LOG_LEVEL_DEBUG 8
#define LOG_LEVEL_OUTPUT 9
//#define CR "\n"
#define LOGGING_VERSION 1_0_3
@ -80,7 +81,8 @@ typedef void (*printfunction)(uint8_t tag, int level, Print *);
* 3 - LOG_LEVEL_WARNING errors and warnings
* 4 - LOG_LEVEL_NOTICE errors, warnings and notices
* 5 - LOG_LEVEL_TRACE errors, warnings, notices, traces
* 6 - LOG_LEVEL_VERBOSE all
* 6 - LOG_LEVEL_VERBOSE subprocesses and steps
* 7 - LOG_LEVEL_DEBUG all
*/
class Logging {
@ -90,7 +92,7 @@ class Logging {
*/
Logging()
#ifndef DISABLE_LOGGING
// : _level(LOG_LEVEL_SILENT), _showLevel(true)
// : _level(LOG_LEVEL_SILENT), _showLevel(true)
#endif
{}
@ -261,7 +263,7 @@ class Logging {
/**
* Output a verbose message. Output message contains
* V: followed by original message
* Debug messages are printed out at
* Verbose messages are printed out at
* loglevels >= LOG_LEVEL_VERBOSE
*
* \param msg format string to output
@ -275,6 +277,39 @@ class Logging {
#endif
}
/**
* Output a debug message. Output message contains
* V: followed by original message
* Debug messages are printed out at
* loglevels >= LOG_LEVEL_DEBUG
*
* \param msg format string to output
* \param ... any number of variables
* \return void
*/
template <class T, typename... Args> void debug(uint8_t tag, T msg, Args... args)
{
#ifndef DISABLE_LOGGING
printLevel(tag, LOG_LEVEL_DEBUG, msg, args...);
#endif
}
/**
* Output a normal message. Output message contains
* V: followed by original message
* Output messages are always printed out
*
* \param msg format string to output
* \param ... any number of variables
* \return void
*/
template <class T, typename... Args> void output(uint8_t tag, T msg, Args... args)
{
#ifndef DISABLE_LOGGING
printLevel(tag, LOG_LEVEL_OUTPUT, msg, args...);
#endif
}
private:
void print(Print * logOutput, const char * format, va_list args);

47
lib/lv_drv_tft_espi/tft_espi_drv.cpp
View File

@ -7,8 +7,9 @@
* INCLUDES
*********************/
#include "../../src/hasp_hal.h" // for halGpioName()
#include "ArduinoLog.h"
#include "tft_espi_drv.h"
#include "ArduinoLog.h"
#include "hasp_macro.h"
#if USE_TFT_ESPI != 0
@ -137,10 +138,10 @@ ADC_MODE(ADC_VCC); // tftShowConfig measures the voltage on the pin
static void tftOffsetInfo(uint8_t pin, uint8_t x_offset, uint8_t y_offset)
{
if(x_offset != 0) {
Log.verbose(TAG_TFT, F("R%u x offset = %i"), pin, x_offset);
LOG_VERBOSE(TAG_TFT, F("R%u x offset = %i"), pin, x_offset);
}
if(y_offset != 0) {
Log.verbose(TAG_TFT, F("R%u y offset = %i"), pin, y_offset);
LOG_VERBOSE(TAG_TFT, F("R%u y offset = %i"), pin, y_offset);
}
}
@ -149,7 +150,7 @@ static void tftPinInfo(const __FlashStringHelper * pinfunction, int8_t pin)
if(pin != -1) {
char buffer[64];
snprintf_P(buffer, sizeof(buffer), PSTR("%-11s: %s (GPIO %02d)"), pinfunction, halGpioName(pin).c_str(), pin);
Log.verbose(TAG_TFT, buffer);
LOG_VERBOSE(TAG_TFT, buffer);
}
}
@ -158,29 +159,29 @@ static void tftShowConfig(TFT_eSPI & tft)
setup_t tftSetup;
tft.getSetup(tftSetup);
Log.verbose(TAG_TFT, F("TFT_eSPI : v%s"), tftSetup.version.c_str());
LOG_VERBOSE(TAG_TFT, F("TFT_eSPI : v%s"), tftSetup.version.c_str());
#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
Log.verbose(TAG_TFT, F("Processor : ESP%x"), tftSetup.esp);
LOG_VERBOSE(TAG_TFT, F("Processor : ESP%x"), tftSetup.esp);
#else
Log.verbose(TAG_TFT, F("Processor : STM%x"), tftSetup.esp);
LOG_VERBOSE(TAG_TFT, F("Processor : STM%x"), tftSetup.esp);
#endif
Log.verbose(TAG_TFT, F("CPU freq. : %i MHz"), halGetCpuFreqMHz());
LOG_VERBOSE(TAG_TFT, F("CPU freq. : %i MHz"), halGetCpuFreqMHz());
#if defined(ARDUINO_ARCH_ESP8266)
Log.verbose(TAG_TFT, F("Voltage : %2.2f V"), ESP.getVcc() / 918.0); // 918 empirically determined
LOG_VERBOSE(TAG_TFT, F("Voltage : %2.2f V"), ESP.getVcc() / 918.0); // 918 empirically determined
#endif
Log.verbose(TAG_TFT, F("Transactns : %s"), (tftSetup.trans == 1) ? PSTR("Yes") : PSTR("No"));
Log.verbose(TAG_TFT, F("Interface : %s"), (tftSetup.serial == 1) ? PSTR("SPI") : PSTR("Parallel"));
LOG_VERBOSE(TAG_TFT, F("Transactns : %s"), (tftSetup.trans == 1) ? PSTR("Yes") : PSTR("No"));
LOG_VERBOSE(TAG_TFT, F("Interface : %s"), (tftSetup.serial == 1) ? PSTR("SPI") : PSTR("Parallel"));
#if defined(ARDUINO_ARCH_ESP8266)
Log.verbose(TAG_TFT, F("SPI overlap: %s"), (tftSetup.overlap == 1) ? PSTR("Yes") : PSTR("No"));
LOG_VERBOSE(TAG_TFT, F("SPI overlap: %s"), (tftSetup.overlap == 1) ? PSTR("Yes") : PSTR("No"));
#endif
if(tftSetup.tft_driver != 0xE9D) // For ePaper displays the size is defined in the sketch
{
Log.verbose(TAG_TFT, F("Driver : %s"), halDisplayDriverName().c_str()); // tftSetup.tft_driver);
Log.verbose(TAG_TFT, F("Resolution : %ix%i"), tftSetup.tft_width, tftSetup.tft_height);
LOG_VERBOSE(TAG_TFT, F("Driver : %s"), halDisplayDriverName().c_str()); // tftSetup.tft_driver);
LOG_VERBOSE(TAG_TFT, F("Resolution : %ix%i"), tftSetup.tft_width, tftSetup.tft_height);
} else if(tftSetup.tft_driver == 0xE9D)
Log.verbose(TAG_TFT, F("Driver = ePaper"));
LOG_VERBOSE(TAG_TFT, F("Driver = ePaper"));
// Offsets, not all used yet
tftOffsetInfo(0, tftSetup.r0_x_offset, tftSetup.r0_y_offset);
@ -202,14 +203,14 @@ static void tftShowConfig(TFT_eSPI & tft)
#if defined(ARDUINO_ARCH_ESP8266)
if(tftSetup.overlap == true) {
Log.verbose(TAG_TFT, F("Overlap selected, following pins MUST be used:"));
LOG_VERBOSE(TAG_TFT, F("Overlap selected, following pins MUST be used:"));
Log.verbose(TAG_TFT, F("MOSI : SD1 (GPIO 8)"));
Log.verbose(TAG_TFT, F("MISO : SD0 (GPIO 7)"));
Log.verbose(TAG_TFT, F("SCK : CLK (GPIO 6)"));
Log.verbose(TAG_TFT, F("TFT_CS : D3 (GPIO 0)"));
LOG_VERBOSE(TAG_TFT, F("MOSI : SD1 (GPIO 8)"));
LOG_VERBOSE(TAG_TFT, F("MISO : SD0 (GPIO 7)"));
LOG_VERBOSE(TAG_TFT, F("SCK : CLK (GPIO 6)"));
LOG_VERBOSE(TAG_TFT, F("TFT_CS : D3 (GPIO 0)"));
Log.verbose(TAG_TFT, F("TFT_DC and TFT_RST pins can be tftSetup defined"));
LOG_VERBOSE(TAG_TFT, F("TFT_DC and TFT_RST pins can be tftSetup defined"));
}
#endif
@ -232,11 +233,11 @@ static void tftShowConfig(TFT_eSPI & tft)
tftPinInfo(F("TFT_D7"), tftSetup.pin_tft_d7);
if(tftSetup.serial == 1) {
Log.verbose(TAG_TFT, F("Display SPI freq. : %d.%d MHz"), tftSetup.tft_spi_freq / 10,
LOG_VERBOSE(TAG_TFT, F("Display SPI freq. : %d.%d MHz"), tftSetup.tft_spi_freq / 10,
tftSetup.tft_spi_freq % 10);
}
if(tftSetup.pin_tch_cs != -1) {
Log.verbose(TAG_TFT, F("Touch SPI freq. : %d.%d MHz"), tftSetup.tch_spi_freq / 10,
LOG_VERBOSE(TAG_TFT, F("Touch SPI freq. : %d.%d MHz"), tftSetup.tch_spi_freq / 10,
tftSetup.tch_spi_freq % 10);
}
}

36
lib/lv_fs_if/lv_fs_spiffs.cpp
View File

@ -152,26 +152,26 @@ static lv_fs_res_t fs_open(lv_fs_drv_t * drv, void * file_p, const char * path,
lv_spiffs_file_t * fp = (lv_spiffs_file_t *)file_p;
if(fp == NULL) return LV_FS_RES_INV_PARAM;
Log.verbose(TAG_LVFS, F("Opening %s"), filename);
LOG_VERBOSE(TAG_LVFS, F("Opening %s"), filename);
lv_spiffs_file_t file = LV_FS_SPIFFS.open(filename, mode == LV_FS_MODE_WR ? FILE_WRITE : FILE_READ);
Log.verbose(TAG_LVFS, F("%d"), __LINE__);
LOG_VERBOSE(TAG_LVFS, F("%d"), __LINE__);
if(!file) {
Log.verbose(TAG_LVFS, F("Invalid file"));
LOG_VERBOSE(TAG_LVFS, F("Invalid file"));
return LV_FS_RES_NOT_EX;
// } else if((*fp).isDirectory()) {
// Log.verbose(TAG_LVFS, F("Cannot open directory as a file"));
// LOG_VERBOSE(TAG_LVFS, F("Cannot open directory as a file"));
// return LV_FS_RES_UNKNOWN;
} else {
// f.seek(0, SeekSet);
// Log.verbose(TAG_LVFS,F("Assigning %s"), f.name());
Log.verbose(TAG_LVFS, F("%d"), __LINE__);
// Log.verbose(TAG_LVFS,F("Copying %s"), f.name());
Log.verbose(TAG_LVFS, F("%d - %x - %d"), __LINE__, fp, sizeof(lv_spiffs_file_t));
// LOG_VERBOSE(TAG_LVFS,F("Assigning %s"), f.name());
LOG_VERBOSE(TAG_LVFS, F("%d"), __LINE__);
// LOG_VERBOSE(TAG_LVFS,F("Copying %s"), f.name());
LOG_VERBOSE(TAG_LVFS, F("%d - %x - %d"), __LINE__, fp, sizeof(lv_spiffs_file_t));
// memcpy(fp,&file,sizeof(lv_spiffs_file_t));
Log.verbose(TAG_LVFS, F("%d"), __LINE__);
LOG_VERBOSE(TAG_LVFS, F("%d"), __LINE__);
*fp = file;
return LV_FS_RES_OK;
}
@ -193,7 +193,7 @@ static lv_fs_res_t fs_close(lv_fs_drv_t * drv, void * file_p)
lv_spiffs_file_t file = *fp;
if(!file) {
Log.verbose(TAG_LVFS, F("Invalid file"));
LOG_VERBOSE(TAG_LVFS, F("Invalid file"));
return LV_FS_RES_NOT_EX;
} else if(file.isDirectory()) {
@ -224,22 +224,22 @@ static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_
lv_spiffs_file_t file = *fp;
if(!file) {
Log.error(TAG_LVFS, F("Invalid file"));
LOG_ERROR(TAG_LVFS, F("Invalid file"));
return LV_FS_RES_NOT_EX;
} else {
// Log.verbose(TAG_LVFS, F("Reading %u bytes from %s at position %u"), btr, file.name(), file.position());
// LOG_VERBOSE(TAG_LVFS, F("Reading %u bytes from %s at position %u"), btr, file.name(), file.position());
uint32_t len = 0;
char * chp = (char *)buf;
if(chp != NULL && btr > 0)
len = file.readBytes(chp, btr);
else
Log.verbose(TAG_LVFS, F("Buffer is NULL"), btr, file.name(), file.position());
LOG_VERBOSE(TAG_LVFS, F("Buffer is NULL"), btr, file.name(), file.position());
if(br != NULL)
*br = len;
else
Log.verbose(TAG_LVFS, F("BYTESREAD is NULL"), btr, file.name(), file.position());
LOG_VERBOSE(TAG_LVFS, F("BYTESREAD is NULL"), btr, file.name(), file.position());
Serial.print("!");
return LV_FS_RES_OK;
@ -262,7 +262,7 @@ static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf,
// File file = fp;
if(!file) {
// Log.verbose(TAG_LVFS,F("Invalid file"));
// LOG_VERBOSE(TAG_LVFS,F("Invalid file"));
return LV_FS_RES_NOT_EX;
} else {
@ -286,7 +286,7 @@ static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos)
// File file = fp;
if(!file) {
// Log.verbose(TAG_LVFS,F("Invalid file"));
// LOG_VERBOSE(TAG_LVFS,F("Invalid file"));
return LV_FS_RES_NOT_EX;
} else {
@ -309,7 +309,7 @@ static lv_fs_res_t fs_size(lv_fs_drv_t * drv, void * file_p, uint32_t * size_p)
// File file = fp;
if(!file) {
// Log.verbose(TAG_LVFS,F("Invalid file"));
// LOG_VERBOSE(TAG_LVFS,F("Invalid file"));
return LV_FS_RES_NOT_EX;
} else {
@ -333,7 +333,7 @@ static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
// File file = fp;
if(!file) {
// Log.verbose(TAG_LVFS,F("Invalid file"));
// LOG_VERBOSE(TAG_LVFS,F("Invalid file"));
return LV_FS_RES_NOT_EX;
} else {

21
lib/lv_lib_zifont/lv_zifont.cpp
View File

@ -26,6 +26,7 @@
#include "lv_misc/lv_debug.h"
#include "lv_zifont.h"
#include "ArduinoLog.h"
#include "hasp_macro.h"
/*********************
* DEFINES
@ -96,7 +97,7 @@ static inline bool openFont(File & file, const char * filename)
file = FS.open(filename, "r");
if(!file) {
Log.error(TAG_FONT, F("Opening font: %s"), filename);
LOG_ERROR(TAG_FONT, F("Opening font: %s"), filename);
return false;
}
return file;
@ -107,14 +108,14 @@ static inline bool initCharacterFrame(size_t size)
if(size > _lv_mem_get_size(charBitmap_p)) {
lv_mem_free(charBitmap_p);
charBitmap_p = (uint8_t *)lv_mem_alloc(size);
Log.warning(TAG_FONT, F("Pixel buffer is %d bytes"), _lv_mem_get_size(charBitmap_p));
LOG_WARNING(TAG_FONT, F("Pixel buffer is %d bytes"), _lv_mem_get_size(charBitmap_p));
}
if(charBitmap_p != NULL) {
_lv_memset_00(charBitmap_p, size); // init the bitmap to white
return true;
} else {
Log.error(TAG_FONT, F("Failed to allocate pixel buffer"));
LOG_ERROR(TAG_FONT, F("Failed to allocate pixel buffer"));
return false;
}
}
@ -158,14 +159,14 @@ int lv_zifont_font_init(lv_font_t ** font, const char * font_path, uint16_t size
/* Check that we read the correct size */
if(readSize != sizeof(zi_font_header_t)) {
Log.error(TAG_FONT, F("Error reading ziFont Header"));
LOG_ERROR(TAG_FONT, F("Error reading ziFont Header"));
file.close();
return ZIFONT_ERROR_READING_DATA;
}
/* Check ziFile Header Format */
if(header.Password != 4 || header.Version != 5) {
Log.error(TAG_FONT, F("Unknown font file format"));
LOG_ERROR(TAG_FONT, F("Unknown font file format"));
file.close();
return ZIFONT_ERROR_UNKNOWN_HEADER;
}
@ -195,12 +196,12 @@ int lv_zifont_font_init(lv_font_t ** font, const char * font_path, uint16_t size
//* Check that we read the correct size
if(readSize != sizeof(lv_zifont_char_t) * CHAR_CACHE_SIZE) {
Log.error(TAG_FONT, F("Error reading ziFont character map"));
LOG_ERROR(TAG_FONT, F("Error reading ziFont character map"));
file.close();
return ZIFONT_ERROR_READING_DATA;
}
Log.verbose(TAG_FONT, F("Loaded V%d Font File: %s containing %d characters"), header.Version, font_path,
LOG_VERBOSE(TAG_FONT, F("Loaded V%d Font File: %s containing %d characters"), header.Version, font_path,
header.Maximumnumchars);
file.close();
@ -309,7 +310,7 @@ const uint8_t * IRAM_ATTR lv_font_get_bitmap_fmt_zifont(const lv_font_t * font,
if(readSize != sizeof(lv_zifont_char_t)) {
file.close();
lv_mem_free(charInfo);
Log.error(TAG_FONT, F("Wrong number of bytes read from flash"));
LOG_ERROR(TAG_FONT, F("Wrong number of bytes read from flash"));
return NULL;
}
@ -317,7 +318,7 @@ const uint8_t * IRAM_ATTR lv_font_get_bitmap_fmt_zifont(const lv_font_t * font,
if(charInfo->character != unicode_letter) {
file.close();
lv_mem_free(charInfo);
Log.error(TAG_FONT, F("Incorrect letter read from flash"));
LOG_ERROR(TAG_FONT, F("Incorrect letter read from flash"));
return NULL;
}
}
@ -412,7 +413,7 @@ const uint8_t * IRAM_ATTR lv_font_get_bitmap_fmt_zifont(const lv_font_t * font,
colorsAdd(charBitmap_p, color2, arrindex++);
}
// if(unicode_letter == 0xf015)
// Log.verbose(TAG_FONT, F("read %d => %d / %d (%d / %d) %d"), len, fileindex, charInfo->length,
// LOG_VERBOSE(TAG_FONT, F("read %d => %d / %d (%d / %d) %d"), len, fileindex, charInfo->length,
// arrindex,
// size, k);
}

4
platformio.ini
View File

@ -57,10 +57,12 @@ build_flags =
; -- StreamUtils build options ----------------------------
-D STREAMUTILS_ENABLE_EEPROM=1 ; for STM32, it also supports EEPROM
;-D DISABLE_LOGGING
; -- Hasp build options ----------------------------
-D HASP_VER_MAJ=0
-D HASP_VER_MIN=3
-D HASP_VER_REV=3
-D HASP_LOG_LEVEL=9
-D HASP_USE_CONFIG=1 ; Native application, not library
${override.build_flags}

14
src/drv/hasp_drv_ft5206.cpp
View File

@ -20,7 +20,7 @@ bool FT5206_getXY(int16_t * touchX, int16_t * touchY, bool debug)
*touchY = tp.y;
if(debug) {
Log.verbose(TAG_DRVR, F("FT5206 touched x: %d y: %d\n"), tp.x, tp.y);
LOG_VERBOSE(TAG_DRVR, F("FT5206 touched x: %d y: %d\n"), tp.x, tp.y);
}
return true;
@ -63,19 +63,19 @@ void scan(TwoWire & i2c)
// void FT5206_init(TwoWire & i2c)
void FT5206_init()
{
Log.trace(TAG_DRVR, F("Touch SDA : %d"), TOUCH_SDA);
Log.trace(TAG_DRVR, F("Touch SCL : %d"), TOUCH_SCL);
Log.trace(TAG_DRVR, F("Touch freq. : %d"), TOUCH_FREQUENCY);
Log.trace(TAG_DRVR, F("Touch address : %02x"), FT5206_address);
LOG_INFO(TAG_DRVR, F("Touch SDA : %d"), TOUCH_SDA);
LOG_INFO(TAG_DRVR, F("Touch SCL : %d"), TOUCH_SCL);
LOG_INFO(TAG_DRVR, F("Touch freq. : %d"), TOUCH_FREQUENCY);
LOG_INFO(TAG_DRVR, F("Touch address : %02x"), FT5206_address);
Wire1.begin(TOUCH_SDA, TOUCH_SCL, TOUCH_FREQUENCY);
scan(Wire1);
touchpanel = new FT5206_Class();
if(touchpanel->begin(Wire1, FT5206_address)) {
Log.trace(TAG_DRVR, F("FT5206 touch driver started"));
LOG_INFO(TAG_DRVR, F("FT5206 touch driver started"));
} else {
Log.error(TAG_DRVR, F("FT5206 touch driver failed to start"));
LOG_ERROR(TAG_DRVR, F("FT5206 touch driver failed to start"));
}
}
#endif

12
src/drv/hasp_drv_ft6336u.cpp
View File

@ -56,10 +56,10 @@ void scan(TwoWire & i2c)
void FT6336U_init()
{
Log.trace(TAG_DRVR, F("Touch SDA : %d"), TOUCH_SDA);
Log.trace(TAG_DRVR, F("Touch SCL : %d"), TOUCH_SCL);
Log.trace(TAG_DRVR, F("Touch freq. : %d"), TOUCH_FREQUENCY);
Log.trace(TAG_DRVR, F("Touch address : %x"), I2C_ADDR_FT6336U);
LOG_INFO(TAG_DRVR, F("Touch SDA : %d"), TOUCH_SDA);
LOG_INFO(TAG_DRVR, F("Touch SCL : %d"), TOUCH_SCL);
LOG_INFO(TAG_DRVR, F("Touch freq. : %d"), TOUCH_FREQUENCY);
LOG_INFO(TAG_DRVR, F("Touch address : %x"), I2C_ADDR_FT6336U);
touchpanel = new FT6336U(TOUCH_SDA, TOUCH_SCL, TOUCH_RST, TOUCH_IRQ);
touchpanel->begin();
@ -79,9 +79,9 @@ void FT6336U_init()
scan(Wire1);
if(touchpanel->read_chip_id() != 0) {
Log.trace(TAG_DRVR, F("FT6336U touch driver started chipid: %d"), touchpanel->read_chip_id());
LOG_INFO(TAG_DRVR, F("FT6336U touch driver started chipid: %d"), touchpanel->read_chip_id());
} else {
Log.error(TAG_DRVR, F("FT6336U touch driver failed to start"));
LOG_ERROR(TAG_DRVR, F("FT6336U touch driver failed to start"));
}
}
#endif

6
src/drv/hasp_drv_gt911.cpp
View File

@ -19,9 +19,9 @@ void GT911_setXY(int8_t contacts, GTPoint * points)
GT911_num_touches = contacts;
GT911_points = points;
Log.verbose(TAG_GUI, F("Contacts: %d"), contacts);
LOG_VERBOSE(TAG_GUI, F("Contacts: %d"), contacts);
for(int i = 0; i < contacts; i++) {
Log.verbose(TAG_GUI, F("C%d: #%d %d,%d s:%d"), i, points[i].trackId, points[i].x, points[i].y, points[i].area);
LOG_VERBOSE(TAG_GUI, F("C%d: #%d %d,%d s:%d"), i, points[i].trackId, points[i].x, points[i].y, points[i].area);
yield();
}
}
@ -98,7 +98,7 @@ void GT911_init()
touch.setHandler(GT911_setXY);
touchStart();
Log.trace(TAG_DRVR, F("Goodix GT911x touch driver started"));
LOG_INFO(TAG_DRVR, F("Goodix GT911x touch driver started"));
}
void GT911_loop()

44
src/hasp/hasp.cpp
View File

@ -313,9 +313,9 @@ void haspSetup(void)
// lv_fs_res_t res;
// res = lv_fs_open(&f, "E:/config.json", LV_FS_MODE_RD);
// if(res == LV_FS_RES_OK)
// Log.verbose(TAG_HASP, F("Opening config.json OK"));
// LOG_VERBOSE(TAG_HASP, F("Opening config.json OK"));
// else
// Log.error(TAG_HASP, F("Opening config.json from FS failed %d"), res);
// LOG_ERROR(TAG_HASP, F("Opening config.json from FS failed %d"), res);
// uint32_t btoread = 128;
// uint32_t bread = 0;
@ -323,17 +323,17 @@ void haspSetup(void)
// res = lv_fs_read(&f, buffer, btoread, &bread);
// if(res == LV_FS_RES_OK) {
// Log.verbose(TAG_HASP, F("Reading config.json OK %u"), bread);
// LOG_VERBOSE(TAG_HASP, F("Reading config.json OK %u"), bread);
// buffer[127] = '\0';
// Log.trace(TAG_HASP, buffer);
// LOG_INFO(TAG_HASP, buffer);
// } else
// Log.error(TAG_HASP, F("Reading config.json from FS failed %d"), res);
// LOG_ERROR(TAG_HASP, F("Reading config.json from FS failed %d"), res);
// res = lv_fs_close(&f);
// if(res == LV_FS_RES_OK)
// Log.verbose(TAG_HASP, F("Closing config.json OK"));
// LOG_VERBOSE(TAG_HASP, F("Closing config.json OK"));
// else
// Log.error(TAG_HASP, F("Closing config.json on FS failed %d"), res);
// LOG_ERROR(TAG_HASP, F("Closing config.json on FS failed %d"), res);
/******* File System Test ********************************************************************/
/* ********** Font Initializations ********** */
@ -343,7 +343,7 @@ void haspSetup(void)
lv_zifont_init();
if(lv_zifont_font_init(&haspFonts[1], haspZiFontPath, 32) != 0) {
Log.error(TAG_HASP, F("Failed to set font to %s"), haspZiFontPath);
LOG_ERROR(TAG_HASP, F("Failed to set font to %s"), haspZiFontPath);
haspFonts[1] = LV_FONT_DEFAULT;
} else {
// defaultFont = haspFonts[0];
@ -430,14 +430,14 @@ void haspSetup(void)
default:
Log.error(TAG_HASP, F("Unknown theme selected"));
LOG_ERROR(TAG_HASP, F("Unknown theme selected"));
}
if(th) {
lv_theme_set_act(th);
Log.trace(TAG_HASP, F("Custom theme loaded"));
LOG_INFO(TAG_HASP, F("Custom theme loaded"));
} else {
Log.error(TAG_HASP, F("Theme could not be loaded"));
LOG_ERROR(TAG_HASP, F("Theme could not be loaded"));
}
/* Create all screens using the theme */
@ -522,11 +522,11 @@ void haspClearPage(uint16_t pageid)
{
lv_obj_t * page = get_page_obj(pageid);
if(!page || (pageid > HASP_NUM_PAGES)) {
Log.warning(TAG_HASP, F(D_HASP_INVALID_PAGE), pageid);
LOG_WARNING(TAG_HASP, F(D_HASP_INVALID_PAGE), pageid);
} else if(page == lv_layer_sys() /*|| page == lv_layer_top()*/) {
Log.warning(TAG_HASP, F(D_HASP_INVALID_LAYER));
LOG_WARNING(TAG_HASP, F(D_HASP_INVALID_LAYER));
} else {
Log.notice(TAG_HASP, F(D_HASP_CLEAR_PAGE), pageid);
LOG_TRACE(TAG_HASP, F(D_HASP_CLEAR_PAGE), pageid);
lv_obj_clean(page);
}
}
@ -540,9 +540,9 @@ void haspSetPage(uint8_t pageid)
{
lv_obj_t * page = get_page_obj(pageid);
if(!page || pageid == 0 || pageid > HASP_NUM_PAGES) {
Log.warning(TAG_HASP, F(D_HASP_INVALID_PAGE), pageid);
LOG_WARNING(TAG_HASP, F(D_HASP_INVALID_PAGE), pageid);
} else {
Log.notice(TAG_HASP, F(D_HASP_CHANGE_PAGE), pageid);
LOG_TRACE(TAG_HASP, F(D_HASP_CHANGE_PAGE), pageid);
current_page = pageid;
lv_scr_load(page);
hasp_object_tree(page, pageid, 0);
@ -555,29 +555,29 @@ void haspLoadPage(const char * pagesfile)
if(pagesfile[0] == '\0') return;
if(!filesystemSetup()) {
Log.error(TAG_HASP, F("FS not mounted. Failed to load %s"), pagesfile);
LOG_ERROR(TAG_HASP, F("FS not mounted. Failed to load %s"), pagesfile);
return;
}
if(!HASP_FS.exists(pagesfile)) {
Log.error(TAG_HASP, F("Non existing file %s"), pagesfile);
LOG_ERROR(TAG_HASP, F("Non existing file %s"), pagesfile);
return;
}
Log.notice(TAG_HASP, F("Loading file %s"), pagesfile);
LOG_TRACE(TAG_HASP, F("Loading file %s"), pagesfile);
File file = HASP_FS.open(pagesfile, "r");
dispatch_parse_jsonl(file);
file.close();
Log.trace(TAG_HASP, F("File %s loaded"), pagesfile);
LOG_INFO(TAG_HASP, F("File %s loaded"), pagesfile);
#else
#if HASP_USE_EEPROM > 0
Log.notice(TAG_HASP, F("Loading jsonl from EEPROM..."));
LOG_TRACE(TAG_HASP, F("Loading jsonl from EEPROM..."));
EepromStream eepromStream(4096, 1024);
dispatch_parse_jsonl(eepromStream);
Log.trace(TAG_HASP, F("Loaded jsonl from EEPROM"));
LOG_INFO(TAG_HASP, F("Loaded jsonl from EEPROM"));
#endif
#endif

113
src/hasp/hasp_attribute.cpp
View File

@ -135,11 +135,11 @@ static bool attribute_lookup_lv_property(uint16_t hash, uint8_t * prop)
for(uint32_t i = 0; i < sizeof(props) / sizeof(props[0]); i++) {
if(props[i].hash == hash) {
*prop = props[1].prop;
Log.warning(TAG_ATTR, F("%d found and has propery %d"), hash, props[i].prop);
LOG_WARNING(TAG_ATTR, F("%d found and has propery %d"), hash, props[i].prop);
return true;
}
}
Log.error(TAG_ATTR, F("%d has no property id"), hash);
LOG_ERROR(TAG_ATTR, F("%d has no property id"), hash);
return false;
}
@ -232,16 +232,16 @@ lv_chart_series_t * my_chart_get_series(lv_obj_t * chart, uint8_t ser_num)
*/
void my_obj_set_value_str_txt(lv_obj_t * obj, uint8_t part, lv_state_t state, const char * text)
{
// Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
// LOG_VERBOSE(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
const void * value_str_p = lv_obj_get_style_value_str(obj, part);
lv_obj_invalidate(obj);
if(text == NULL || text[0] == 0) {
// Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
// LOG_VERBOSE(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
lv_obj_set_style_local_value_str(obj, part, state, NULL);
lv_mem_free(value_str_p);
// Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
// LOG_VERBOSE(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
return;
}
@ -252,15 +252,15 @@ void my_obj_set_value_str_txt(lv_obj_t * obj, uint8_t part, lv_state_t state, co
size_t len = strlen(text) + 1;
/*Allocate space for the new text*/
// Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
// LOG_VERBOSE(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
value_str_p = (char *)lv_mem_alloc(len);
LV_ASSERT_MEM(value_str_p);
if(value_str_p == NULL) return;
// Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
// LOG_VERBOSE(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
strncpy((char *)value_str_p, text, len);
lv_obj_set_style_local_value_str(obj, part, state, (char *)value_str_p);
// Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
// LOG_VERBOSE(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
return;
}
@ -268,7 +268,7 @@ void my_obj_set_value_str_txt(lv_obj_t * obj, uint8_t part, lv_state_t state, co
if(value_str_p == text) {
/*If set its own text then reallocate it (maybe its size changed)*/
Log.warning(TAG_ATTR, "%s %d", __FILE__, __LINE__);
LOG_DEBUG(TAG_ATTR, "%s %d", __FILE__, __LINE__);
return; // don't touch the data
// value_str_p = lv_mem_realloc(value_str_p, strlen(text) + 1);
@ -278,10 +278,10 @@ void my_obj_set_value_str_txt(lv_obj_t * obj, uint8_t part, lv_state_t state, co
} else {
/*Free the old text*/
if(value_str_p != NULL) {
// Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
// LOG_DEBUG(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
lv_mem_free(value_str_p);
value_str_p = NULL;
// Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
// LOG_DEBUG(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
}
/*Get the size of the text*/
@ -294,7 +294,7 @@ void my_obj_set_value_str_txt(lv_obj_t * obj, uint8_t part, lv_state_t state, co
lv_obj_set_style_local_value_str(obj, part, state, (char *)value_str_p);
}
// Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
// LOG_VERBOSE(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
}
void my_btnmatrix_map_clear(lv_obj_t * obj)
@ -302,23 +302,23 @@ void my_btnmatrix_map_clear(lv_obj_t * obj)
lv_btnmatrix_ext_t * ext = (lv_btnmatrix_ext_t *)lv_obj_get_ext_attr(obj);
const char ** map_p_tmp = ext->map_p; // store current pointer
Log.verbose(TAG_ATTR, "%s %d %x btn_cnt: %d", __FILE__, __LINE__, map_p_tmp, ext->btn_cnt);
LOG_VERBOSE(TAG_ATTR, "%s %d %x btn_cnt: %d", __FILE__, __LINE__, map_p_tmp, ext->btn_cnt);
if(ext->map_p && (ext->btn_cnt > 0)) {
// The map exists and is not the default lvgl map anymore
if((map_p_tmp == NULL) || (btnmatrix_default_map == NULL) || (map_p_tmp == btnmatrix_default_map)) return;
Log.verbose(TAG_ATTR, "%s %d %x", __FILE__, __LINE__,
*map_p_tmp); // label buffer reserved as a contiguous block
Log.verbose(TAG_ATTR, "%s %d %x", __FILE__, __LINE__, map_p_tmp); // label pointer array block
lv_btnmatrix_set_map(obj, btnmatrix_default_map); // reset to default btnmap pointer
LOG_DEBUG(TAG_ATTR, "%s %d %x", __FILE__, __LINE__,
*map_p_tmp); // label buffer reserved as a contiguous block
LOG_DEBUG(TAG_ATTR, "%s %d %x", __FILE__, __LINE__, map_p_tmp); // label pointer array block
lv_btnmatrix_set_map(obj, btnmatrix_default_map); // reset to default btnmap pointer
Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
LOG_DEBUG(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
lv_mem_free(*map_p_tmp); // free label buffer reserved as a contiguous block
Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
LOG_DEBUG(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
lv_mem_free(map_p_tmp); // free label pointer array block
Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
LOG_DEBUG(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
}
}
@ -342,7 +342,7 @@ static void my_btnmatrix_map_create(lv_obj_t * obj, const char * payload)
size_t tot_len = sizeof(char *) * (arr.size() + 1);
const char ** map_data_str = (const char **)lv_mem_alloc(tot_len);
if(map_data_str == NULL) {
return Log.error(TAG_ATTR, F("Out of memory while creating button map"));
return LOG_ERROR(TAG_ATTR, F("Out of memory while creating button map"));
}
memset(map_data_str, 0, tot_len);
@ -352,26 +352,26 @@ static void my_btnmatrix_map_create(lv_obj_t * obj, const char * payload)
tot_len += btn.as<String>().length() + 1;
}
tot_len++; // trailing '\0'
Log.verbose(TAG_ATTR, F("Array Size = %d, Map Length = %d"), arr.size(), tot_len);
LOG_VERBOSE(TAG_ATTR, F("Array Size = %d, Map Length = %d"), arr.size(), tot_len);
char * buffer_addr = (char *)lv_mem_alloc(tot_len);
if(buffer_addr == NULL) {
lv_mem_free(map_data_str);
return Log.error(TAG_ATTR, F("Out of memory while creating button map"));
return LOG_ERROR(TAG_ATTR, F("Out of memory while creating button map"));
}
memset(buffer_addr, 0, tot_len); // Important, last index needs to be 0 => empty string ""
/* Point of no return, destroy & free the previous map */
Log.verbose(TAG_ATTR, F("%s %d map addr: %x"), __FILE__, __LINE__, map_data_str);
LOG_VERBOSE(TAG_ATTR, F("%s %d map addr: %x"), __FILE__, __LINE__, map_data_str);
my_btnmatrix_map_clear(obj); // Free previous map
// Fill buffer
size_t index = 0;
size_t pos = 0;
Log.verbose(TAG_ATTR, F("%s %d lbl addr: %x"), __FILE__, __LINE__, buffer_addr);
LOG_VERBOSE(TAG_ATTR, F("%s %d lbl addr: %x"), __FILE__, __LINE__, buffer_addr);
for(JsonVariant btn : arr) {
size_t len = btn.as<String>().length() + 1;
Log.verbose(TAG_ATTR, F(D_BULLET "Adding button: %s (%d bytes) %x"), btn.as<String>().c_str(), len,
LOG_VERBOSE(TAG_ATTR, F(D_BULLET "Adding button: %s (%d bytes) %x"), btn.as<String>().c_str(), len,
buffer_addr + pos);
memccpy(buffer_addr + pos, btn.as<String>().c_str(), 0, len); // Copy the label text into the buffer
map_data_str[index++] = buffer_addr + pos; // save pointer to the label in the array
@ -379,9 +379,9 @@ static void my_btnmatrix_map_create(lv_obj_t * obj, const char * payload)
}
map_data_str[index] = buffer_addr + pos; // save pointer to the last \0 byte
Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
LOG_VERBOSE(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
lv_btnmatrix_set_map(obj, map_data_str);
Log.verbose(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
LOG_VERBOSE(TAG_ATTR, F("%s %d"), __FILE__, __LINE__);
}
void line_clear_points(lv_obj_t * obj)
@ -414,7 +414,7 @@ static void line_set_points(lv_obj_t * obj, const char * payload)
size_t tot_len = sizeof(lv_point_t *) * (arr.size());
lv_point_t * point_arr = (lv_point_t *)lv_mem_alloc(tot_len);
if(point_arr == NULL) {
return Log.error(TAG_ATTR, F("Out of memory while creating line points"));
return LOG_ERROR(TAG_ATTR, F("Out of memory while creating line points"));
}
memset(point_arr, 0, tot_len);
@ -423,7 +423,7 @@ static void line_set_points(lv_obj_t * obj, const char * payload)
JsonArray point = v.as<JsonArray>(); // Parse point
point_arr[index].x = point[0].as<int16_t>();
point_arr[index].y = point[1].as<int16_t>();
Log.verbose(TAG_ATTR, F(D_BULLET "Adding point %d: %d,%d"), index, point_arr[index].x, point_arr[index].y);
LOG_VERBOSE(TAG_ATTR, F(D_BULLET "Adding point %d: %d,%d"), index, point_arr[index].x, point_arr[index].y);
index++;
}
@ -438,7 +438,7 @@ static inline lv_color_t haspLogColor(lv_color_t color)
// uint8_t r = (LV_COLOR_GET_R(color) * 263 + 7) >> 5;
// uint8_t g = (LV_COLOR_GET_G(color) * 259 + 3) >> 6;
// uint8_t b = (LV_COLOR_GET_B(color) * 263 + 7) >> 5;
// Log.verbose(TAG_ATTR,F("Color: R%u G%u B%u"), r, g, b);
// LOG_VERBOSE(TAG_ATTR,F("Color: R%u G%u B%u"), r, g, b);
return color;
}
@ -590,7 +590,7 @@ static void hasp_process_label_long_mode(lv_obj_t * obj, const char * payload, b
} else if(!strcasecmp_P(payload, PSTR("crop"))) {
mode = LV_LABEL_LONG_CROP;
} else {
return Log.warning(TAG_ATTR, F("Invalid long mode"));
return LOG_WARNING(TAG_ATTR, F("Invalid long mode"));
}
lv_label_set_long_mode(obj, mode);
} else {
@ -621,10 +621,10 @@ lv_obj_t * FindButtonLabel(lv_obj_t * btn)
#endif
} else {
Log.error(TAG_ATTR, F("FindButtonLabel NULL Pointer encountered"));
LOG_ERROR(TAG_ATTR, F("FindButtonLabel NULL Pointer encountered"));
}
} else {
Log.warning(TAG_ATTR, F("Button not defined"));
LOG_WARNING(TAG_ATTR, F("Button not defined"));
}
return NULL;
}
@ -642,7 +642,7 @@ static inline void haspSetLabelText(lv_obj_t * obj, const char * value)
static bool haspGetLabelText(lv_obj_t * obj, char ** text)
{
if(!obj) {
Log.warning(TAG_ATTR, F("Button not defined"));
LOG_WARNING(TAG_ATTR, F("Button not defined"));
return false;
}
@ -664,7 +664,7 @@ static bool haspGetLabelText(lv_obj_t * obj, char ** text)
#endif
} else {
Log.warning(TAG_ATTR, F("haspGetLabelText NULL Pointer encountered"));
LOG_WARNING(TAG_ATTR, F("haspGetLabelText NULL Pointer encountered"));
}
return false;
@ -909,8 +909,15 @@ static void hasp_local_style_attr(lv_obj_t * obj, const char * attr_p, uint16_t
lv_obj_set_style_local_text_font(obj, part, state, font);
if(check_obj_type(obj, LV_HASP_ROLLER)) lv_roller_set_visible_row_count(obj, count);
lv_obj_set_style_local_text_font(obj, part, state, font); // again, for roller
if(check_obj_type(obj, LV_HASP_DDLIST)) { // issue #43
lv_obj_set_style_local_text_font(obj, LV_DROPDOWN_PART_MAIN, state, font);
lv_obj_set_style_local_text_font(obj, LV_DROPDOWN_PART_LIST, state, font);
lv_obj_set_style_local_text_font(obj, LV_DROPDOWN_PART_SELECTED, state, font);
};
} else {
Log.warning(TAG_ATTR, F("Unknown Font ID %s"), payload);
LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), payload);
}
return;
}
@ -1057,7 +1064,7 @@ static void hasp_local_style_attr(lv_obj_t * obj, const char * attr_p, uint16_t
if(font) {
return lv_obj_set_style_local_value_font(obj, part, state, font);
} else {
return Log.warning(TAG_ATTR, F("Unknown Font ID %s"), attr_p);
return LOG_WARNING(TAG_ATTR, F("Unknown Font ID %s"), attr_p);
}
}
@ -1092,7 +1099,7 @@ static void hasp_local_style_attr(lv_obj_t * obj, const char * attr_p, uint16_t
/* Transition attributes */
// Todo
}
Log.warning(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr_p);
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr_p);
}
static void hasp_process_arc_attribute(lv_obj_t * obj, const char * attr_p, uint16_t attr_hash, const char * payload,
@ -1136,7 +1143,7 @@ static void hasp_process_arc_attribute(lv_obj_t * obj, const char * attr_p, uint
return (update) ? lv_arc_set_end_angle(obj, val) : hasp_out_int(obj, attr, lv_arc_get_angle_end(obj));
}
Log.warning(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr_p);
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr_p);
}
static void hasp_process_lmeter_attribute(lv_obj_t * obj, const char * attr_p, uint16_t attr_hash, const char * payload,
@ -1168,7 +1175,7 @@ static void hasp_process_lmeter_attribute(lv_obj_t * obj, const char * attr_p, u
return (update) ? lv_linemeter_set_scale(obj, val, line_count) : hasp_out_int(obj, attr, angle);
}
Log.warning(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr_p);
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr_p);
}
static void hasp_process_gauge_attribute(lv_obj_t * obj, const char * attr_p, uint16_t attr_hash, const char * payload,
@ -1225,7 +1232,7 @@ static void hasp_process_gauge_attribute(lv_obj_t * obj, const char * attr_p, ui
return;
}
Log.warning(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr_p);
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr_p);
}
// ##################### Common Attributes ########################################################
@ -1269,7 +1276,7 @@ static void hasp_process_obj_attribute_txt(lv_obj_t * obj, const char * attr, co
}
#endif
Log.warning(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr);
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr);
}
bool hasp_process_obj_attribute_val(lv_obj_t * obj, const char * attr, const char * payload, bool update)
@ -1379,7 +1386,7 @@ static void hasp_process_obj_attribute_range(lv_obj_t * obj, const char * attr,
: hasp_out_int(obj, attr, set_min ? min : max);
}
Log.warning(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr);
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN), attr);
}
// ##################### Default Attributes ########################################################
@ -1395,14 +1402,14 @@ static void hasp_process_obj_attribute_range(lv_obj_t * obj, const char * attr,
void hasp_process_obj_attribute(lv_obj_t * obj, const char * attr_p, const char * payload, bool update)
{
// unsigned long start = millis();
if(!obj) return Log.warning(TAG_ATTR, F(D_OBJECT_UNKNOWN));
if(!obj) return LOG_WARNING(TAG_ATTR, F(D_OBJECT_UNKNOWN));
int16_t val = atoi(payload);
char * attr = (char *)attr_p;
if(*attr == '.') attr++; // strip leading '.'
uint16_t attr_hash = hasp_util_get_sdbm(attr);
// Log.verbose(TAG_ATTR,"%s => %d", attr, attr_hash);
// LOG_VERBOSE(TAG_ATTR,"%s => %d", attr, attr_hash);
/* 16-bit Hash Lookup Table */
switch(attr_hash) {
@ -1416,7 +1423,7 @@ void hasp_process_obj_attribute(lv_obj_t * obj, const char * attr_p, const char
case ATTR_OBJID:
if(update) {
Log.warning(TAG_ATTR, F("%s is read-only"), attr_p);
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_READ_ONLY), attr_p);
} else {
hasp_out_int(obj, attr, obj->user_data.objid);
}
@ -1665,21 +1672,21 @@ void hasp_process_obj_attribute(lv_obj_t * obj, const char * attr_p, const char
case ATTR_DELETE:
if(!lv_obj_get_parent(obj)) {
return Log.error(TAG_ATTR, F(D_ATTRIBUTE_PAGE_METHOD_INVALID), attr_p);
return LOG_ERROR(TAG_ATTR, F(D_ATTRIBUTE_PAGE_METHOD_INVALID), attr_p);
}
lv_obj_del_async(obj);
break; // attribute_found
case ATTR_TO_FRONT:
if(!lv_obj_get_parent(obj)) {
return Log.error(TAG_ATTR, F(D_ATTRIBUTE_PAGE_METHOD_INVALID), attr_p);
return LOG_ERROR(TAG_ATTR, F(D_ATTRIBUTE_PAGE_METHOD_INVALID), attr_p);
}
lv_obj_move_foreground(obj);
break; // attribute_found
case ATTR_TO_BACK:
if(!lv_obj_get_parent(obj)) {
return Log.error(TAG_ATTR, F(D_ATTRIBUTE_PAGE_METHOD_INVALID), attr_p);
return LOG_ERROR(TAG_ATTR, F(D_ATTRIBUTE_PAGE_METHOD_INVALID), attr_p);
}
lv_obj_move_background(obj);
break; // attribute_found
@ -1689,10 +1696,10 @@ void hasp_process_obj_attribute(lv_obj_t * obj, const char * attr_p, const char
}
attribute_found:
// Log.verbose(TAG_ATTR, F("%s (%d)"), attr_p, attr_hash);
// Log.verbose(TAG_ATTR, F("%s (%d) took %d ms."), attr_p, attr_hash, millis() - start);
// LOG_VERBOSE(TAG_ATTR, F("%s (%d)"), attr_p, attr_hash);
// LOG_VERBOSE(TAG_ATTR, F("%s (%d) took %d ms."), attr_p, attr_hash, millis() - start);
return;
attribute_not_found:
Log.warning(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash);
LOG_WARNING(TAG_ATTR, F(D_ATTRIBUTE_UNKNOWN " (%d)"), attr_p, attr_hash);
}

36
src/hasp/hasp_dispatch.cpp
View File

@ -58,13 +58,13 @@ void dispatch_screenshot(const char *, const char * filename)
memcpy_P(tempfile, PSTR("/screenshot.bmp"), sizeof(tempfile));
guiTakeScreenshot(tempfile);
} else if(strlen(filename) > 31 || filename[0] != '/') { // Invalid filename
Log.warning(TAG_MSGR, "Invalid filename %s", filename);
LOG_WARNING(TAG_MSGR, "Invalid filename %s", filename);
} else { // Valid filename
guiTakeScreenshot(filename);
}
#else
Log.warning(TAG_MSGR, "Failed to save %s, no storage", filename);
LOG_WARNING(TAG_MSGR, "Failed to save %s, no storage", filename);
#endif
}
@ -87,7 +87,7 @@ bool dispatch_factory_reset()
void dispatch_json_error(uint8_t tag, DeserializationError & jsonError)
{
Log.error(tag, F(D_JSON_FAILED " %s"), jsonError.c_str());
LOG_ERROR(tag, F(D_JSON_FAILED " %s"), jsonError.c_str());
}
// p[x].b[y].attr=value
@ -195,7 +195,7 @@ void dispatch_command(const char * topic, const char * payload)
// check and execute commands from commands array
for(int i = 0; i < nCommands; i++) {
if(!strcasecmp_P(topic, commands[i].p_cmdstr)) {
// Log.warning(TAG_MSGR, F("Command %d found in array !!!"), i);
// LOG_DEBUG(TAG_MSGR, F("Command %d found in array !!!"), i);
commands[i].func(topic, payload); /* execute command */
return;
}
@ -241,14 +241,14 @@ void dispatch_command(const char * topic, const char * payload)
if(strlen(payload) == 0) {
// dispatch_text_line(topic); // Could cause an infinite loop!
}
Log.warning(TAG_MSGR, F(D_DISPATCH_COMMAND_NOT_FOUND " => %s"), topic, payload);
LOG_WARNING(TAG_MSGR, F(D_DISPATCH_COMMAND_NOT_FOUND " => %s"), topic, payload);
}
}
// Strip command/config prefix from the topic and process the payload
void dispatch_topic_payload(const char * topic, const char * payload)
{
// Log.verbose(TAG_MSGR,F("TOPIC: short topic: %s"), topic);
// LOG_VERBOSE(TAG_MSGR,F("TOPIC: short topic: %s"), topic);
if(!strcmp_P(topic, PSTR("command"))) {
dispatch_text_line((char *)payload);
@ -300,11 +300,11 @@ void dispatch_text_line(const char * cmnd)
memcpy(topic, cmnd, sizeof(topic) - 1);
// topic is before '=', payload is after '=' position
Log.notice(TAG_MSGR, F("%s=%s"), topic, cmnd + pos + 1);
LOG_TRACE(TAG_MSGR, F("%s=%s"), topic, cmnd + pos + 1);
dispatch_topic_payload(topic, cmnd + pos + 1);
} else {
char empty_payload[1] = {0};
Log.notice(TAG_MSGR, F("%s=%s"), cmnd, empty_payload);
LOG_TRACE(TAG_MSGR, F("%s=%s"), cmnd, empty_payload);
dispatch_topic_payload(cmnd, empty_payload);
}
}
@ -558,7 +558,7 @@ void dispatch_object_value_changed(lv_obj_t * obj, int16_t state)
static inline void dispatch_state_msg(const __FlashStringHelper * subtopic, const char * payload)
{
#if !defined(HASP_USE_MQTT) && !defined(HASP_USE_TASMOTA_SLAVE)
Log.notice(TAG_MSGR, F("%s => %s"), String(subtopic).c_str(), payload);
LOG_TRACE(TAG_MSGR, F("%s => %s"), String(subtopic).c_str(), payload);
#else
#if HASP_USE_MQTT > 0
mqtt_send_state(subtopic, payload);
@ -598,7 +598,7 @@ static inline void dispatch_state_msg(const __FlashStringHelper * subtopic, cons
void dispatch_normalized_group_value(uint8_t groupid, uint16_t value, lv_obj_t * obj)
{
if(groupid > 0) {
Log.verbose(TAG_MSGR, F("GROUP %d value %d"), groupid, value);
LOG_VERBOSE(TAG_MSGR, F("GROUP %d value %d"), groupid, value);
gpio_set_normalized_group_value(groupid, value);
// object_set_group_state(groupid, value, obj);
}
@ -646,7 +646,7 @@ void dispatch_parse_json(const char *, const char * payload)
dispatch_text_line(json.as<String>().c_str());
} else {
Log.warning(TAG_MSGR, F(D_DISPATCH_COMMAND_NOT_FOUND), payload);
LOG_WARNING(TAG_MSGR, F(D_DISPATCH_COMMAND_NOT_FOUND), payload);
}
}
@ -672,10 +672,10 @@ void dispatch_parse_jsonl(std::istringstream & stream)
/* For debugging pourposes */
if(jsonError == DeserializationError::EmptyInput) {
Log.trace(TAG_MSGR, F(D_JSONL_SUCCEEDED));
LOG_INFO(TAG_MSGR, F(D_JSONL_SUCCEEDED));
} else {
Log.error(TAG_MSGR, F(D_JSONL_FAILED ": %s"), line, jsonError.c_str());
LOG_ERROR(TAG_MSGR, F(D_JSONL_FAILED ": %s"), line, jsonError.c_str());
}
}
@ -713,7 +713,7 @@ void dispatch_page(const char *, const char * page)
} else if(!strcasecmp_P(page, PSTR("next"))) {
dispatch_page_next();
} else {
Log.warning(TAG_MSGR, PSTR(D_DISPATCH_INVALID_PAGE), page);
LOG_WARNING(TAG_MSGR, PSTR(D_DISPATCH_INVALID_PAGE), page);
}
return;
}
@ -825,7 +825,7 @@ void dispatch_backlight(const char *, const char * payload)
void dispatch_web_update(const char *, const char * espOtaUrl)
{
#if HASP_USE_OTA > 0
Log.notice(TAG_MSGR, F(D_OTA_CHECK_UPDATE), espOtaUrl);
LOG_TRACE(TAG_MSGR, F(D_OTA_CHECK_UPDATE), espOtaUrl);
otaHttpUpdate(espOtaUrl);
#endif
}
@ -845,8 +845,8 @@ void dispatch_reboot(bool saveConfig)
#if HASP_USE_WIFI > 0
wifiStop();
#endif
Log.verbose(TAG_MSGR, F("-------------------------------------"));
Log.notice(TAG_MSGR, F(D_DISPATCH_REBOOT));
LOG_VERBOSE(TAG_MSGR, F("-------------------------------------"));
LOG_TRACE(TAG_MSGR, F(D_DISPATCH_REBOOT));
Serial.flush();
halRestartMcu();
}
@ -934,7 +934,7 @@ void dispatch_factory_reset(const char *, const char *)
static void dispatch_add_command(const char * p_cmdstr, void (*func)(const char *, const char *))
{
if(nCommands >= sizeof(commands) / sizeof(haspCommand_t)) {
Log.fatal(TAG_MSGR, F("CMD_OVERFLOW %d"), nCommands);
LOG_FATAL(TAG_MSGR, F("CMD_OVERFLOW %d"), nCommands);
while(1) {
}
} else {

42
src/hasp/hasp_object.cpp
View File

@ -51,7 +51,7 @@ lv_obj_t * hasp_find_obj_from_parent_id(lv_obj_t * parent, uint8_t objid)
uint16_t tabcount = lv_tabview_get_tab_count(child);
for(uint16_t i = 0; i < tabcount; i++) {
lv_obj_t * tab = lv_tabview_get_tab(child, i);
Log.verbose(TAG_HASP, "Found tab %i", i);
LOG_VERBOSE(TAG_HASP, "Found tab %i", i);
if(tab->user_data.objid && objid == tab->user_data.objid) return tab; /* tab found, return it */
/* check grandchildren */
@ -181,7 +181,7 @@ void hasp_object_tree(lv_obj_t * parent, uint8_t pageid, uint16_t level)
lv_obj_type_t list;
lv_obj_get_type(parent, &list);
const char * objtype = list.type[0];
Log.verbose(TAG_HASP, F("[%d] " HASP_OBJECT_NOTATION " %s"), level, pageid, parent->user_data.id, objtype);
LOG_VERBOSE(TAG_HASP, F("[%d] " HASP_OBJECT_NOTATION " %s"), level, pageid, parent->user_data.id, objtype);
lv_obj_t * child;
child = lv_obj_get_child(parent, NULL);
@ -199,7 +199,7 @@ void hasp_object_tree(lv_obj_t * parent, uint8_t pageid, uint16_t level)
uint16_t tabcount = lv_tabview_get_tab_count(parent);
for(uint16_t i = 0; i < tabcount; i++) {
lv_obj_t * tab = lv_tabview_get_tab(parent, i);
Log.verbose(TAG_HASP, "Found tab %i", i);
LOG_VERBOSE(TAG_HASP, "Found tab %i", i);
if(tab->user_data.objid) hasp_object_tree(tab, pageid, level + 1);
}
#endif
@ -319,18 +319,18 @@ void generic_event_handler(lv_obj_t * obj, lv_event_t event)
return;
case LV_EVENT_VALUE_CHANGED:
Log.warning(TAG_HASP, F("Value changed Event %d occured"), event);
LOG_WARNING(TAG_HASP, F("Value changed Event %d occured"), event);
last_press_was_short = false;
return;
case LV_EVENT_DELETE:
Log.verbose(TAG_HASP, F(D_OBJECT_DELETED));
LOG_VERBOSE(TAG_HASP, F(D_OBJECT_DELETED));
hasp_object_delete(obj); // free and destroy persistent memory allocated for certain objects
last_press_was_short = false;
return;
default:
Log.warning(TAG_HASP, F(D_OBJECT_EVENT_UNKNOWN), event);
LOG_WARNING(TAG_HASP, F(D_OBJECT_EVENT_UNKNOWN), event);
last_press_was_short = false;
return;
}
@ -388,7 +388,7 @@ void toggle_event_handler(lv_obj_t * obj, lv_event_t event)
dispatch_normalized_group_value(obj->user_data.groupid, NORMALIZE(val, 0, 1), obj);
} else if(event == LV_EVENT_DELETE) {
Log.verbose(TAG_HASP, F(D_OBJECT_DELETED));
LOG_VERBOSE(TAG_HASP, F(D_OBJECT_DELETED));
hasp_object_delete(obj);
}
}
@ -450,7 +450,7 @@ static void selector_event_handler(lv_obj_t * obj, lv_event_t event)
if(max > 0) dispatch_normalized_group_value(obj->user_data.groupid, NORMALIZE(val, 0, max), obj);
} else if(event == LV_EVENT_DELETE) {
Log.verbose(TAG_HASP, F(D_OBJECT_DELETED));
LOG_VERBOSE(TAG_HASP, F(D_OBJECT_DELETED));
hasp_object_delete(obj);
}
}
@ -495,7 +495,7 @@ void slider_event_handler(lv_obj_t * obj, lv_event_t event)
dispatch_normalized_group_value(obj->user_data.groupid, NORMALIZE(val, min, max), obj);
} else if(event == LV_EVENT_DELETE) {
Log.verbose(TAG_HASP, F(D_OBJECT_DELETED));
LOG_VERBOSE(TAG_HASP, F(D_OBJECT_DELETED));
hasp_object_delete(obj);
}
}
@ -514,7 +514,7 @@ static void cpicker_event_handler(lv_obj_t * obj, lv_event_t event)
hasp_update_sleep_state(); // wakeup?
hasp_send_obj_attribute_color(obj, color, lv_cpicker_get_color(obj));
} else if(event == LV_EVENT_DELETE) {
Log.verbose(TAG_HASP, F(D_OBJECT_DELETED));
LOG_VERBOSE(TAG_HASP, F(D_OBJECT_DELETED));
hasp_object_delete(obj);
}
}
@ -557,7 +557,7 @@ void object_set_group_value(lv_obj_t * parent, uint8_t groupid, const char * pay
uint16_t tabcount = lv_tabview_get_tab_count(child);
for(uint16_t i = 0; i < tabcount; i++) {
lv_obj_t * tab = lv_tabview_get_tab(child, i);
Log.verbose(TAG_HASP, F("Found tab %i"), i);
LOG_VERBOSE(TAG_HASP, F("Found tab %i"), i);
if(tab->user_data.groupid && groupid == tab->user_data.groupid)
hasp_process_obj_attribute_val(tab, NULL, payload, true); /* tab found, update it */
@ -586,7 +586,7 @@ void hasp_process_attribute(uint8_t pageid, uint8_t objid, const char * attr, co
if(lv_obj_t * obj = hasp_find_obj_from_parent_id(get_page_obj(pageid), objid)) {
hasp_process_obj_attribute(obj, attr, payload, strlen(payload) > 0);
} else {
Log.warning(TAG_HASP, F(D_OBJECT_UNKNOWN " " HASP_OBJECT_NOTATION), pageid, objid);
LOG_WARNING(TAG_HASP, F(D_OBJECT_UNKNOWN " " HASP_OBJECT_NOTATION), pageid, objid);
}
}
@ -604,7 +604,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
uint8_t pageid = config[FPSTR(FP_PAGE)].isNull() ? saved_page_id : config[FPSTR(FP_PAGE)].as<uint8_t>();
lv_obj_t * parent_obj = get_page_obj(pageid);
if(!parent_obj) {
return Log.warning(TAG_HASP, F(D_OBJECT_PAGE_UNKNOWN), pageid);
return LOG_WARNING(TAG_HASP, F(D_OBJECT_PAGE_UNKNOWN), pageid);
} else {
saved_page_id = pageid; /* save the current pageid */
}
@ -614,10 +614,10 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
uint8_t parentid = config[FPSTR(FP_PARENTID)].as<uint8_t>();
parent_obj = hasp_find_obj_from_parent_id(parent_obj, parentid);
if(!parent_obj) {
return Log.warning(TAG_HASP, F("Parent ID " HASP_OBJECT_NOTATION " not found, skipping..."), pageid,
return LOG_WARNING(TAG_HASP, F("Parent ID " HASP_OBJECT_NOTATION " not found, skipping..."), pageid,
parentid);
} else {
Log.verbose(TAG_HASP, F("Parent ID " HASP_OBJECT_NOTATION " found"), pageid, parentid);
LOG_VERBOSE(TAG_HASP, F("Parent ID " HASP_OBJECT_NOTATION " found"), pageid, parentid);
}
}
@ -944,12 +944,12 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
/* ----- Other Object ------ */
// default:
// return Log.warning(TAG_HASP, F("Unsupported Object ID %u"), objid);
// return LOG_WARNING(TAG_HASP, F("Unsupported Object ID %u"), objid);
}
/* No object was actually created */
if(!obj) {
return Log.error(TAG_HASP, F(D_OBJECT_CREATE_FAILED), id);
return LOG_ERROR(TAG_HASP, F(D_OBJECT_CREATE_FAILED), id);
}
// Prevent losing press when the press is slid out of the objects.
@ -964,18 +964,18 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
/** testing start **/
uint8_t temp;
if(!hasp_find_id_from_obj(obj, &pageid, &temp)) {
return Log.error(TAG_HASP, F(D_OBJECT_LOST));
return LOG_ERROR(TAG_HASP, F(D_OBJECT_LOST));
}
/** verbose reporting **/
lv_obj_type_t list;
lv_obj_get_type(obj, &list);
Log.verbose(TAG_HASP, F(D_BULLET HASP_OBJECT_NOTATION " = %s"), pageid, temp, list.type[0]);
LOG_VERBOSE(TAG_HASP, F(D_BULLET HASP_OBJECT_NOTATION " = %s"), pageid, temp, list.type[0]);
/* test double-check */
lv_obj_t * test = hasp_find_obj_from_parent_id(get_page_obj(pageid), (uint8_t)temp);
if(test != obj) {
return Log.error(TAG_HASP, F(D_OBJECT_MISMATCH));
return LOG_ERROR(TAG_HASP, F(D_OBJECT_MISMATCH));
}
}
@ -992,7 +992,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
for(JsonPair keyValue : config) {
v = keyValue.value().as<String>();
hasp_process_obj_attribute(obj, keyValue.key().c_str(), v.c_str(), true);
// Log.verbose(TAG_HASP,F(" * %s => %s"), keyValue.key().c_str(), v.c_str());
// LOG_VERBOSE(TAG_HASP,F(" * %s => %s"), keyValue.key().c_str(), v.c_str());
}
}

88
src/hasp_config.cpp
View File

@ -29,7 +29,7 @@ void confDebugSet(const __FlashStringHelper * fstr_name)
/*char buffer[128];
snprintf_P(buffer, sizeof(buffer), PSTR(" * %s set"), name);
debugPrintln(buffer);*/
Log.verbose(TAG_CONF, F(" * %S set"), fstr_name);
LOG_VERBOSE(TAG_CONF, F(D_BULLET "%S set"), fstr_name);
}
bool configSet(int8_t & value, const JsonVariant & setting, const __FlashStringHelper * fstr_name)
@ -74,15 +74,15 @@ void configStartDebug(bool setupdebug, String & configFile)
if(setupdebug) {
debugStart(); // Debug started, now we can use it; HASP header sent
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
Log.trace(TAG_CONF, F("SPI flash FS mounted"));
LOG_INFO(TAG_CONF, F("SPI flash FS mounted"));
filesystemInfo();
filesystemList();
#endif
}
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
Log.notice(TAG_CONF, F("Loading %s"), configFile.c_str());
LOG_TRACE(TAG_CONF, F("Loading %s"), configFile.c_str());
#else
Log.notice(TAG_CONF, F("reading EEPROM"));
LOG_TRACE(TAG_CONF, F("reading EEPROM"));
#endif
}
@ -99,7 +99,7 @@ void configGetConfig(JsonDocument & settings, bool setupdebug = false)
if(file) {
size_t size = file.size();
if(size > 1024) {
Log.error(TAG_CONF, F("Config file size is too large"));
LOG_ERROR(TAG_CONF, F("Config file size is too large"));
return;
}
@ -120,8 +120,8 @@ void configGetConfig(JsonDocument & settings, bool setupdebug = false)
output.replace(settings[FPSTR(FP_HTTP)][F("pass")].as<String>(), passmask);
output.replace(settings[FPSTR(FP_MQTT)][F("pass")].as<String>(), passmask);
output.replace(settings[FPSTR(FP_WIFI)][F("pass")].as<String>(), passmask);
Log.verbose(TAG_CONF, output.c_str());
Log.trace(TAG_CONF, F("Loaded %s"), configFile.c_str());
LOG_VERBOSE(TAG_CONF, output.c_str());
LOG_INFO(TAG_CONF, F("Loaded %s"), configFile.c_str());
if(setupdebug) debugSetup();
return;
@ -143,7 +143,7 @@ void configGetConfig(JsonDocument & settings, bool setupdebug = false)
configStartDebug(setupdebug, configFile);
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
Log.error(TAG_CONF, F("Failed to load %s"), configFile.c_str());
LOG_ERROR(TAG_CONF, F("Failed to load %s"), configFile.c_str());
#endif
}
/*
@ -171,7 +171,7 @@ void configBackupToEeprom()
file.close();
EEPROM.commit();
Log.trace(TAG_CONF,F("Written %u to EEPROM"), index);
LOG_INFO(TAG_CONF,F("Written %u to EEPROM"), index);
}
#endif
}
@ -188,9 +188,9 @@ void configWriteConfig()
/* Read Config File */
DynamicJsonDocument doc(8 * 256);
Log.notice(TAG_CONF, F("Config LOADING first %s"), configFile.c_str());
LOG_TRACE(TAG_CONF, F("Config LOADING first %s"), configFile.c_str());
configGetConfig(doc, false);
Log.trace(TAG_CONF, F("Config LOADED first %s"), configFile.c_str());
LOG_INFO(TAG_CONF, F("Config LOADED first %s"), configFile.c_str());
// Make sure we have a valid JsonObject to start from
JsonObject settings;
@ -209,7 +209,7 @@ void configWriteConfig()
if(settings[module].as<JsonObject>().isNull()) settings.createNestedObject(module);
changed = wifiGetConfig(settings[module]);
if(changed) {
Log.verbose(TAG_WIFI, settingsChanged.c_str());
LOG_VERBOSE(TAG_WIFI, settingsChanged.c_str());
configOutput(settings[module], TAG_WIFI);
writefile = true;
}
@ -220,7 +220,7 @@ void configWriteConfig()
if(settings[module].as<JsonObject>().isNull()) settings.createNestedObject(module);
changed = mqttGetConfig(settings[module]);
if(changed) {
Log.verbose(TAG_MQTT, settingsChanged.c_str());
LOG_VERBOSE(TAG_MQTT, settingsChanged.c_str());
configOutput(settings[module], TAG_MQTT);
writefile = true;
}
@ -231,7 +231,7 @@ void configWriteConfig()
if(settings[module].as<JsonObject>().isNull()) settings.createNestedObject(module);
changed = telnetGetConfig(settings[module]);
if(changed) {
Log.verbose(TAG_TELN, settingsChanged.c_str());
LOG_VERBOSE(TAG_TELN, settingsChanged.c_str());
configOutput(settings[module], TAG_TELN);
writefile = true;
}
@ -242,7 +242,7 @@ void configWriteConfig()
if(settings[module].as<JsonObject>().isNull()) settings.createNestedObject(module);
changed = mdnsGetConfig(settings[module]);
if(changed) {
Log.verbose(TAG_MDNS, settingsChanged.c_str());
LOG_VERBOSE(TAG_MDNS, settingsChanged.c_str());
configOutput(settings[module], TAG_MDNS);
writefile = true;
}
@ -252,7 +252,7 @@ void configWriteConfig()
if(settings[FPSTR(FP_HTTP)].as<JsonObject>().isNull()) settings.createNestedObject(F("http"));
changed = httpGetConfig(settings[FPSTR(FP_HTTP)]);
if(changed) {
Log.verbose(TAG_HTTP, settingsChanged.c_str());
LOG_VERBOSE(TAG_HTTP, settingsChanged.c_str());
configOutput(settings[FPSTR(FP_HTTP)], TAG_HTTP);
writefile = true;
}
@ -263,7 +263,7 @@ void configWriteConfig()
if(settings[module].as<JsonObject>().isNull()) settings.createNestedObject(module);
changed = gpioGetConfig(settings[module]);
if(changed) {
Log.verbose(TAG_GPIO, settingsChanged.c_str());
LOG_VERBOSE(TAG_GPIO, settingsChanged.c_str());
configOutput(settings[module], TAG_GPIO);
writefile = true;
}
@ -273,7 +273,7 @@ void configWriteConfig()
if(settings[module].as<JsonObject>().isNull()) settings.createNestedObject(module);
changed = debugGetConfig(settings[module]);
if(changed) {
Log.verbose(TAG_DEBG, settingsChanged.c_str());
LOG_VERBOSE(TAG_DEBG, settingsChanged.c_str());
configOutput(settings[module], TAG_DEBG);
writefile = true;
}
@ -281,7 +281,7 @@ void configWriteConfig()
if(settings[FPSTR(FP_GUI)].as<JsonObject>().isNull()) settings.createNestedObject(FPSTR(FP_GUI));
changed = guiGetConfig(settings[FPSTR(FP_GUI)]);
if(changed) {
Log.verbose(TAG_GUI, settingsChanged.c_str());
LOG_VERBOSE(TAG_GUI, settingsChanged.c_str());
configOutput(settings[FPSTR(FP_GUI)], TAG_GUI);
writefile = true;
}
@ -289,7 +289,7 @@ void configWriteConfig()
if(settings[FPSTR(FP_HASP)].as<JsonObject>().isNull()) settings.createNestedObject(FPSTR(FP_HASP));
changed = haspGetConfig(settings[FPSTR(FP_HASP)]);
if(changed) {
Log.verbose(TAG_HASP, settingsChanged.c_str());
LOG_VERBOSE(TAG_HASP, settingsChanged.c_str());
configOutput(settings[FPSTR(FP_HASP)], TAG_HASP);
writefile = true;
}
@ -300,22 +300,22 @@ void configWriteConfig()
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
File file = HASP_FS.open(configFile, "w");
if(file) {
Log.notice(TAG_CONF, F("Writing %s"), configFile.c_str());
LOG_TRACE(TAG_CONF, F("Writing %s"), configFile.c_str());
size_t size = serializeJson(doc, file);
file.close();
if(size > 0) {
Log.trace(TAG_CONF, F("Saved %s"), configFile.c_str());
LOG_INFO(TAG_CONF, F("Saved %s"), configFile.c_str());
// configBackupToEeprom();
} else {
Log.error(TAG_CONF, F("Failed to write %s"), configFile.c_str());
LOG_ERROR(TAG_CONF, F("Failed to write %s"), configFile.c_str());
}
} else {
Log.error(TAG_CONF, F("Failed to write %s"), configFile.c_str());
LOG_ERROR(TAG_CONF, F("Failed to write %s"), configFile.c_str());
}
#endif
// Method 1
// Log.trace(TAG_CONF,F("Writing to EEPROM"));
// LOG_INFO(TAG_CONF,F("Writing to EEPROM"));
// EepromStream eepromStream(0, 1024);
// WriteBufferingStream bufferedWifiClient{eepromStream, 512};
// serializeJson(doc, bufferedWifiClient);
@ -324,7 +324,7 @@ void configWriteConfig()
#if defined(STM32F4xx)
// Method 2
Log.trace(TAG_CONF, F("Writing to EEPROM"));
LOG_INFO(TAG_CONF, F("Writing to EEPROM"));
char buffer[1024 + 128];
size_t size = serializeJson(doc, buffer, sizeof(buffer));
if(size > 0) {
@ -332,14 +332,14 @@ void configWriteConfig()
for(i = 0; i < size; i++) eeprom_buffered_write_byte(i, buffer[i]);
eeprom_buffered_write_byte(i, 0);
eeprom_buffer_flush();
Log.trace(TAG_CONF, F("Saved EEPROM"));
LOG_INFO(TAG_CONF, F("Saved EEPROM"));
} else {
Log.error(TAG_CONF, F("Failed to save config to EEPROM"));
LOG_ERROR(TAG_CONF, F("Failed to save config to EEPROM"));
}
#endif
} else {
Log.trace(TAG_CONF, F("Configuration did not change"));
LOG_INFO(TAG_CONF, F("Configuration did not change"));
}
configOutput(settings, TAG_CONF);
}
@ -362,7 +362,7 @@ void configSetup()
} else {
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
if(!filesystemSetup()) {
Log.error(TAG_CONF, F("FILE: SPI flash init failed. Unable to mount FS: Using default settings..."));
LOG_ERROR(TAG_CONF, F("FILE: SPI flash init failed. Unable to mount FS: Using default settings..."));
return;
}
#endif
@ -370,45 +370,45 @@ void configSetup()
}
//#if HASP_USE_SPIFFS > 0
Log.trace(TAG_DEBG, F("Loading debug settings"));
LOG_INFO(TAG_DEBG, F("Loading debug settings"));
debugSetConfig(settings[FPSTR(FP_DEBUG)]);
Log.trace(TAG_GPIO, F("Loading GUI settings"));
LOG_INFO(TAG_GPIO, F("Loading GUI settings"));
guiSetConfig(settings[FPSTR(FP_GUI)]);
Log.trace(TAG_HASP, F("Loading HASP settings"));
LOG_INFO(TAG_HASP, F("Loading HASP settings"));
haspSetConfig(settings[FPSTR(FP_HASP)]);
// otaGetConfig(settings[F("ota")]);
#if HASP_USE_WIFI > 0
Log.trace(TAG_WIFI, F("Loading WiFi settings"));
LOG_INFO(TAG_WIFI, F("Loading WiFi settings"));
wifiSetConfig(settings[FPSTR(FP_WIFI)]);
#endif
#if HASP_USE_MQTT > 0
Log.trace(TAG_MQTT, F("Loading MQTT settings"));
LOG_INFO(TAG_MQTT, F("Loading MQTT settings"));
mqttSetConfig(settings[FPSTR(FP_MQTT)]);
#endif
#if HASP_USE_TELNET > 0
Log.trace(TAG_TELN, F("Loading Telnet settings"));
LOG_INFO(TAG_TELN, F("Loading Telnet settings"));
telnetSetConfig(settings[F("telnet")]);
#endif
#if HASP_USE_MDNS > 0
Log.trace(TAG_MDNS, F("Loading MDNS settings"));
LOG_INFO(TAG_MDNS, F("Loading MDNS settings"));
mdnsSetConfig(settings[FPSTR(FP_MDNS)]);
#endif
#if HASP_USE_HTTP > 0
Log.trace(TAG_HTTP, F("Loading HTTP settings"));
LOG_INFO(TAG_HTTP, F("Loading HTTP settings"));
httpSetConfig(settings[FPSTR(FP_HTTP)]);
#endif
#if HASP_USE_GPIO > 0
Log.trace(TAG_GPIO, F("Loading GPIO settings"));
LOG_INFO(TAG_GPIO, F("Loading GPIO settings"));
gpioSetConfig(settings[FPSTR(FP_GPIO)]);
#endif
Log.trace(TAG_CONF, F("User configuration loaded"));
LOG_INFO(TAG_CONF, F("User configuration loaded"));
}
//#endif
}
@ -458,13 +458,13 @@ void configOutput(const JsonObject & settings, uint8_t tag)
output.replace(password, passmask);
}
Log.verbose(tag, output.c_str());
LOG_VERBOSE(tag, output.c_str());
}
bool configClearEeprom()
{
#if defined(STM32F4xx)
Log.notice(TAG_CONF, F("Clearing EEPROM"));
LOG_TRACE(TAG_CONF, F("Clearing EEPROM"));
char buffer[1024 + 128];
memset(buffer, 1, sizeof(buffer));
if(sizeof(buffer) > 0) {
@ -472,10 +472,10 @@ bool configClearEeprom()
for(i = 0; i < sizeof(buffer); i++) eeprom_buffered_write_byte(i, buffer[i]);
eeprom_buffered_write_byte(i, 0);
eeprom_buffer_flush();
Log.trace(TAG_CONF, F("Cleared EEPROM"));
LOG_INFO(TAG_CONF, F("Cleared EEPROM"));
return true;
} else {
Log.error(TAG_CONF, F("Failed to clear to EEPROM"));
LOG_ERROR(TAG_CONF, F("Failed to clear to EEPROM"));
return false;
}
#elif HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0

39
src/hasp_debug.cpp
View File

@ -3,13 +3,13 @@
/* ===========================================================================
- Log.fatal() - A fatal exception is caught, the program should halt with while(1){}
- Log.error() - An important but non-fatal error occured, this error should be checked and not ignored
- Log.warning() - Send at the end of a function to indicate failure of the sub process, can be ignored
- LOG_FATAL() - A fatal exception is caught, the program should halt with while(1){}
- LOG_ERROR() - An important but non-fatal error occured, this error should be checked and not ignored
- LOG_WARNING() - Send at the end of a function to indicate failure of the sub process, can be ignored
- Log.notice() - Information at the START of an action to notify another function is now running
- Log.trace() - Send at the END of a function to indicate successful completion of the sub process
- Log.verbose() - Send DEBUG information DURING a subprocess
- LOG_TRACE() - Information at the START of an action to notify another function is now running
- LOG_INFO() - Send at the END of a function to indicate successful completion of the sub process
- LOG_VERBOSE() - Send DEBUG information DURING a subprocess
=========================================================================== */
@ -151,7 +151,7 @@ void debugSetup()
{
// memset(serialInputBuffer, 0, sizeof(serialInputBuffer));
// serialInputIndex = 0;
Log.notice(TAG_DEBG, F(D_SERVICE_STARTING)); // Starting console
LOG_TRACE(TAG_DEBG, F(D_SERVICE_STARTING)); // Starting console
debugConsole.setLineCallback(dispatch_text_line);
}
@ -172,10 +172,10 @@ void debugStartSyslog()
if(syslogClient) {
if(syslogClient->beginPacket(debugSyslogHost, debugSyslogPort)) {
Log.registerOutput(2, syslogClient, LOG_LEVEL_VERBOSE, true);
Log.trace(TAG_SYSL, F(D_SERVICE_STARTED));
LOG_INFO(TAG_SYSL, F(D_SERVICE_STARTED));
}
} else {
Log.error(TAG_SYSL, F(D_SERVICE_START_FAILED));
LOG_ERROR(TAG_SYSL, F(D_SERVICE_START_FAILED));
}
}
#endif
@ -185,7 +185,7 @@ void debugStopSyslog()
{
#if HASP_USE_SYSLOG > 0
if(strlen(debugSyslogHost) > 0) {
Log.warning(TAG_SYSL, F(D_SERVICE_STOPPED));
LOG_WARNING(TAG_SYSL, F(D_SERVICE_STOPPED));
Log.unregisterOutput(2);
}
#endif
@ -411,8 +411,7 @@ static void debugPrintPriority(int level, Print * _logOutput)
// }
switch(level) {
case LOG_LEVEL_FATAL:
case LOG_LEVEL_ERROR:
case LOG_LEVEL_FATAL...LOG_LEVEL_ERROR:
debugSendAnsiCode(F(TERM_COLOR_RED), _logOutput);
break;
case LOG_LEVEL_WARNING:
@ -427,6 +426,10 @@ static void debugPrintPriority(int level, Print * _logOutput)
case LOG_LEVEL_VERBOSE:
debugSendAnsiCode(F(TERM_COLOR_CYAN), _logOutput);
break;
case LOG_LEVEL_DEBUG:
debugSendAnsiCode(F(TERM_COLOR_BLUE), _logOutput);
break;
case LOG_LEVEL_OUTPUT:
default:
debugSendAnsiCode(F(TERM_COLOR_RESET), _logOutput);
}
@ -648,8 +651,8 @@ void debugPreSetup(JsonObject settings)
debugPrintHaspHeader(&Serial);
Serial.flush();
Log.trace(TAG_DEBG, F("Serial started at %u baud"), baudrate);
Log.trace(TAG_DEBG, F("Environment: " PIOENV));
LOG_INFO(TAG_DEBG, F("Serial started at %u baud"), baudrate);
LOG_INFO(TAG_DEBG, F("Environment: " PIOENV));
}
}
@ -668,16 +671,16 @@ void debugLvglLogEvent(lv_log_level_t level, const char * file, uint32_t line, c
if(line != lastDbgLine || mem_mon.free_biggest_size != lastDbgFreeMem) {
switch(level) {
case LV_LOG_LEVEL_TRACE:
Log.verbose(TAG_LVGL, descr);
LOG_VERBOSE(TAG_LVGL, descr);
break;
case LV_LOG_LEVEL_WARN:
Log.warning(TAG_LVGL, descr);
LOG_WARNING(TAG_LVGL, descr);
break;
case LV_LOG_LEVEL_ERROR:
Log.error(TAG_LVGL, descr);
LOG_ERROR(TAG_LVGL, descr);
break;
default:
Log.notice(TAG_LVGL, descr);
LOG_TRACE(TAG_LVGL, descr);
}
lastDbgLine = line;
lastDbgFreeMem = mem_mon.free_biggest_size;

8
src/hasp_debug.h
View File

@ -6,6 +6,7 @@
#include "ArduinoJson.h"
#include "ArduinoLog.h"
#include "hasp_macro.h"
#include "lvgl.h"
#include "lang/lang.h"
@ -19,7 +20,8 @@ void debugStart(void);
void debugStop(void);
/* ===== Special Event Processors ===== */
void debugLvglLogEvent(lv_log_level_t level, const char * file, uint32_t line, const char * funcname, const char * descr);
void debugLvglLogEvent(lv_log_level_t level, const char * file, uint32_t line, const char * funcname,
const char * descr);
void debugPrintHaspHeader(Print * output);
void debugStartSyslog(void);
void debugStopSyslog(void);
@ -42,7 +44,7 @@ enum {
TAG_MSGR = 3,
TAG_OOBE = 4,
TAG_HAL = 5,
TAG_DRVR = 6,
TAG_DRVR = 6,
TAG_DEBG = 10,
TAG_TELN = 11,
@ -73,4 +75,4 @@ enum {
TAG_FONT = 92
};
#endif
#endif

12
src/hasp_filesystem.cpp
View File

@ -72,23 +72,23 @@ void filesystemList()
#else
if(!SPIFFS.begin(true)) {
#endif
Log.error(TAG_FILE, F("Flash file system not mouted."));
LOG_ERROR(TAG_FILE, F("Flash file system not mouted."));
} else {
Log.verbose(TAG_FILE, F("Listing files on the internal flash:"));
LOG_VERBOSE(TAG_FILE, F("Listing files on the internal flash:"));
#if defined(ARDUINO_ARCH_ESP32)
File root = SPIFFS.open("/");
File file = root.openNextFile();
while(file) {
Log.verbose(TAG_FILE, F(" * %s (%u bytes)"), file.name(), (uint32_t)file.size());
LOG_VERBOSE(TAG_FILE, F(" * %s (%u bytes)"), file.name(), (uint32_t)file.size());
file = root.openNextFile();
}
#endif
#if defined(ARDUINO_ARCH_ESP8266)
Dir dir = SPIFFS.openDir("/");
while(dir.next()) {
Log.verbose(TAG_FILE, F(" * %s (%u bytes)"), dir.fileName().c_str(), (uint32_t)dir.fileSize());
LOG_VERBOSE(TAG_FILE, F(" * %s (%u bytes)"), dir.fileName().c_str(), (uint32_t)dir.fileSize());
}
#endif
}
@ -109,10 +109,10 @@ bool filesystemSetup(void)
#else
if(!HASP_FS.begin(true)) {
#endif
// Log.error(TAG_FILE, F("SPI flash init failed. Unable to mount FS."));
// LOG_ERROR(TAG_FILE, F("SPI flash init failed. Unable to mount FS."));
return false;
} else {
// Log.trace(TAG_FILE, F("SPI Flash FS mounted"));
// LOG_INFO(TAG_FILE, F("SPI Flash FS mounted"));
return true;
}
#endif

22
src/hasp_gpio.cpp
View File

@ -127,7 +127,7 @@ void gpioAddButton(uint8_t pin, uint8_t input_mode, uint8_t default_state, uint8
for(i = 0; i < HASP_NUM_INPUTS; i++) {
if(!button[i]) {
Log.notice(TAG_GPIO, F("Creating Button%d on pin %d (index %d) mode %d default %d"), i, pin, index,
LOG_TRACE(TAG_GPIO, F("Creating Button%d on pin %d (index %d) mode %d default %d"), i, pin, index,
input_mode, default_state);
button[i] = new AceButton(pin, default_state, index);
@ -145,14 +145,14 @@ void gpioAddButton(uint8_t pin, uint8_t input_mode, uint8_t default_state, uint8
ButtonConfig::kFeatureSuppressClickBeforeDoubleClick); // Causes annoying pauses
buttonConfig->setFeature(ButtonConfig::kFeatureSuppressAfterClick);
Log.trace(TAG_GPIO, F("Button%d created on pin %d (index %d) mode %d default %d"), i, pin, index,
LOG_INFO(TAG_GPIO, F("Button%d created on pin %d (index %d) mode %d default %d"), i, pin, index,
input_mode, default_state);
gpioUsedInputCount = i + 1;
return;
}
}
}
Log.error(TAG_GPIO, F("Failed to create Button%d pin %d (index %d). All %d slots available are in use!"), i, pin,
LOG_ERROR(TAG_GPIO, F("Failed to create Button%d pin %d (index %d). All %d slots available are in use!"), i, pin,
index, HASP_NUM_INPUTS);
}
@ -162,7 +162,7 @@ void gpioAddSwitch(uint8_t pin, uint8_t input_mode, uint8_t default_state, uint8
for(i = 0; i < HASP_NUM_INPUTS; i++) {
if(!button[i]) {
Log.notice(TAG_GPIO, F("Creating Switch%d on pin %d (index %d) mode %d default %d"), i, pin, index,
LOG_TRACE(TAG_GPIO, F("Creating Switch%d on pin %d (index %d) mode %d default %d"), i, pin, index,
input_mode, default_state);
button[i] = new AceButton(pin, default_state, index);
@ -174,14 +174,14 @@ void gpioAddSwitch(uint8_t pin, uint8_t input_mode, uint8_t default_state, uint8
buttonConfig->setEventHandler(gpio_event_handler);
buttonConfig->setFeature(ButtonConfig::kFeatureSuppressAll);
Log.trace(TAG_GPIO, F("Button%d switch on pin %d (index %d) mode %d default %d"), i, pin, index,
LOG_INFO(TAG_GPIO, F("Button%d switch on pin %d (index %d) mode %d default %d"), i, pin, index,
input_mode, default_state);
gpioUsedInputCount = i + 1;
return;
}
}
}
Log.error(TAG_GPIO, F("Failed to create Button%d pin %d (index %d). All %d slots available are in use!"), i, pin,
LOG_ERROR(TAG_GPIO, F("Failed to create Button%d pin %d (index %d). All %d slots available are in use!"), i, pin,
index, HASP_NUM_INPUTS);
}
@ -205,14 +205,14 @@ void gpioAddTouchButton(uint8_t pin, uint8_t input_mode, uint8_t default_state,
buttonConfig->clearFeature(
ButtonConfig::kFeatureSuppressClickBeforeDoubleClick); // Causes annoying pauses
Log.trace(TAG_GPIO, F("Button%d created on pin %d (index %d) mode %d default %d"), i, pin, index,
LOG_INFO(TAG_GPIO, F("Button%d created on pin %d (index %d) mode %d default %d"), i, pin, index,
input_mode, default_state);
gpioUsedInputCount = i + 1;
return;
}
}
}
Log.error(TAG_GPIO, F("Failed to create Button%d pin %d (index %d). All %d slots available are in use!"), i, pin,
LOG_ERROR(TAG_GPIO, F("Failed to create Button%d pin %d (index %d). All %d slots available are in use!"), i, pin,
index, HASP_NUM_INPUTS);
}
@ -318,7 +318,7 @@ void gpio_set_normalized_value(hasp_gpio_config_t gpio, uint16_t state)
default:
return;
}
Log.verbose(TAG_GPIO, F(D_BULLET "Group %d - Pin %d = %d"), gpio.group, gpio.pin, gpio.val);
LOG_VERBOSE(TAG_GPIO, F(D_BULLET "Group %d - Pin %d = %d"), gpio.group, gpio.pin, gpio.val);
}
// void gpio_set_group_onoff(uint8_t groupid, bool ison)
@ -504,7 +504,7 @@ bool gpioSavePinConfig(uint8_t config_num, uint8_t pin, uint8_t type, uint8_t gr
gpioConfig[config_num].type = type;
gpioConfig[config_num].group = group;
gpioConfig[config_num].gpio_function = pinfunc;
Log.notice(TAG_GPIO, F("Saving Pin config #%d pin %d - type %d - group %d - func %d"), config_num, pin, type,
LOG_TRACE(TAG_GPIO, F("Saving Pin config #%d pin %d - type %d - group %d - func %d"), config_num, pin, type,
group, pinfunc);
return true;
}
@ -546,7 +546,7 @@ bool gpioGetConfig(const JsonObject & settings)
if(i < HASP_NUM_GPIO_CONFIG) {
uint32_t cur_val = gpioConfig[i].pin | (gpioConfig[i].group << 8) | (gpioConfig[i].type << 16) |
(gpioConfig[i].gpio_function << 24);
Log.trace(TAG_GPIO, F("GPIO CONF: %d: %d <=> %d"), i, cur_val, v.as<uint32_t>());
LOG_INFO(TAG_GPIO, F("GPIO CONF: %d: %d <=> %d"), i, cur_val, v.as<uint32_t>());
if(cur_val != v.as<uint32_t>()) changed = true;
v.set(cur_val);

46
src/hasp_gui.cpp
View File

@ -159,7 +159,7 @@ static uint16_t calData[5] = {0, 65535, 0, 65535, 0};
// data->point.x = touchX; // 20 + (disp->driver.hor_res - 40) * (touchCorner % 2);
// data->point.y = touchY; // 20 + (disp->driver.ver_res - 40) * (touchCorner / 2);
// Log.verbose(TAG_GUI,F("Calibrate touch %u / %u"), touchX, touchY);
// LOG_VERBOSE(TAG_GUI,F("Calibrate touch %u / %u"), touchX, touchY);
// #endif
@ -283,7 +283,7 @@ void guiSetup()
#endif
if(!guiVdbBuffer1) {
Log.error(TAG_GUI, F("Gram out of memory"));
LOG_ERROR(TAG_GUI, F("Gram out of memory"));
}
static lv_disp_buf_t disp_buf;
@ -302,14 +302,14 @@ void guiSetup()
#endif
#ifdef USE_DMA_TO_TFT
Log.verbose(TAG_GUI, F("DMA : ENABLED"));
LOG_VERBOSE(TAG_GUI, F("DMA : ENABLED"));
#else
Log.verbose(TAG_GUI, F("DMA : DISABLED"));
LOG_VERBOSE(TAG_GUI, F("DMA : DISABLED"));
#endif
/* Setup Backlight Control Pin */
if(guiBacklightPin >= 0) {
Log.verbose(TAG_GUI, F("Backlight : Pin %d"), guiBacklightPin);
LOG_VERBOSE(TAG_GUI, F("Backlight : Pin %d"), guiBacklightPin);
#if defined(ARDUINO_ARCH_ESP32)
ledcSetup(BACKLIGHT_CHANNEL, 20000, 12);
@ -318,18 +318,18 @@ void guiSetup()
pinMode(guiBacklightPin, OUTPUT);
#endif
}
Log.verbose(TAG_GUI, F("Rotation : %d"), guiRotation);
LOG_VERBOSE(TAG_GUI, F("Rotation : %d"), guiRotation);
Log.verbose(TAG_LVGL, F("Version : %u.%u.%u %s"), LVGL_VERSION_MAJOR, LVGL_VERSION_MINOR, LVGL_VERSION_PATCH,
LOG_VERBOSE(TAG_LVGL, F("Version : %u.%u.%u %s"), LVGL_VERSION_MAJOR, LVGL_VERSION_MINOR, LVGL_VERSION_PATCH,
PSTR(LVGL_VERSION_INFO));
#ifdef LV_MEM_SIZE
Log.verbose(TAG_LVGL, F("MEM size : %d"), LV_MEM_SIZE);
LOG_VERBOSE(TAG_LVGL, F("MEM size : %d"), LV_MEM_SIZE);
#endif
Log.verbose(TAG_LVGL, F("VFB size : %d"), (size_t)sizeof(lv_color_t) * guiVDBsize);
LOG_VERBOSE(TAG_LVGL, F("VFB size : %d"), (size_t)sizeof(lv_color_t) * guiVDBsize);
#if LV_USE_LOG != 0
Log.notice(TAG_LVGL, F("Registering lvgl logging handler"));
LOG_TRACE(TAG_LVGL, F("Registering lvgl logging handler"));
lv_log_register_print_cb(debugLvglLogEvent);
#endif
@ -381,7 +381,7 @@ void guiSetup()
// lv_label_set_text(label, "<");
// lv_indev_set_cursor(mouse_indev, label); // connect the object to the driver
Log.notice(TAG_GUI, F("Initialize Cursor"));
LOG_TRACE(TAG_GUI, F("Initialize Cursor"));
lv_obj_t * cursor;
lv_obj_t * mouse_layer = lv_disp_get_layer_sys(NULL); // default display
@ -519,7 +519,7 @@ bool guiGetConfig(const JsonObject & settings)
JsonArray array = settings[FPSTR(FP_GUI_CALIBRATION)].as<JsonArray>();
uint8_t i = 0;
for(JsonVariant v : array) {
Log.verbose(TAG_GUI, F("GUI CONF: %d: %d <=> %d"), i, calData[i], v.as<uint16_t>());
LOG_VERBOSE(TAG_GUI, F("GUI CONF: %d: %d <=> %d"), i, calData[i], v.as<uint16_t>());
if(i < 5) {
if(calData[i] != v.as<uint16_t>()) changed = true;
v.set(calData[i]);
@ -578,7 +578,7 @@ bool guiSetConfig(const JsonObject & settings)
if(!settings[FPSTR(FP_GUI_POINTER)].isNull()) {
if(guiShowPointer != settings[FPSTR(FP_GUI_POINTER)].as<bool>()) {
Log.verbose(TAG_GUI, F("guiShowPointer set"));
LOG_VERBOSE(TAG_GUI, F("guiShowPointer set"));
}
changed |= guiShowPointer != settings[FPSTR(FP_GUI_POINTER)].as<bool>();
@ -599,11 +599,11 @@ bool guiSetConfig(const JsonObject & settings)
}
if(calData[0] != 0 || calData[1] != 65535 || calData[2] != 0 || calData[3] != 65535) {
Log.verbose(TAG_GUI, F("calData set [%u, %u, %u, %u, %u]"), calData[0], calData[1], calData[2], calData[3],
LOG_VERBOSE(TAG_GUI, F("calData set [%u, %u, %u, %u, %u]"), calData[0], calData[1], calData[2], calData[3],
calData[4]);
oobeSetAutoCalibrate(false);
} else {
Log.notice(TAG_GUI, F("First Touch Calibration enabled"));
LOG_TRACE(TAG_GUI, F("First Touch Calibration enabled"));
oobeSetAutoCalibrate(true);
}
@ -686,7 +686,7 @@ static void gui_get_bitmap_header(uint8_t * buffer, size_t bufsize)
void gui_flush_not_complete()
{
Log.warning(TAG_GUI, F("Pixelbuffer not completely sent"));
LOG_WARNING(TAG_GUI, F("Pixelbuffer not completely sent"));
}
#endif // HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0 || HASP_USE_HTTP > 0
@ -720,7 +720,7 @@ void guiTakeScreenshot(const char * pFileName)
size_t len = pFileOut.write(buffer, 122);
if(len == 122) {
Log.verbose(TAG_GUI, F("Bitmap header written"));
LOG_VERBOSE(TAG_GUI, F("Bitmap header written"));
/* Refresh screen to screenshot callback */
lv_disp_t * disp = lv_disp_get_default();
@ -732,15 +732,15 @@ void guiTakeScreenshot(const char * pFileName)
lv_refr_now(NULL); /* Will call our disp_drv.disp_flush function */
disp->driver.flush_cb = flush_cb; /* restore callback */
Log.verbose(TAG_GUI, F("Bitmap data flushed to %s"), pFileName);
LOG_VERBOSE(TAG_GUI, F("Bitmap data flushed to %s"), pFileName);
} else {
Log.error(TAG_GUI, F("Data written does not match header size"));
LOG_ERROR(TAG_GUI, F("Data written does not match header size"));
}
pFileOut.close();
} else {
Log.warning(TAG_GUI, F("%s cannot be opened"), pFileName);
LOG_WARNING(TAG_GUI, F("%s cannot be opened"), pFileName);
}
}
#endif
@ -769,7 +769,7 @@ void guiTakeScreenshot()
gui_get_bitmap_header(buffer, sizeof(buffer));
if(httpClientWrite(buffer, 122) == 122) {
Log.verbose(TAG_GUI, F("Bitmap header sent"));
LOG_VERBOSE(TAG_GUI, F("Bitmap header sent"));
/* Refresh screen to screenshot callback */
lv_disp_t * disp = lv_disp_get_default();
@ -780,9 +780,9 @@ void guiTakeScreenshot()
lv_refr_now(NULL); /* Will call our disp_drv.disp_flush function */
disp->driver.flush_cb = flush_cb; /* restore callback */
Log.verbose(TAG_GUI, F("Bitmap data flushed to webclient"));
LOG_VERBOSE(TAG_GUI, F("Bitmap data flushed to webclient"));
} else {
Log.error(TAG_GUI, F("Data sent does not match header size"));
LOG_ERROR(TAG_GUI, F("Data sent does not match header size"));
}
}
#endif

12
src/hasp_oobe.cpp
View File

@ -77,7 +77,7 @@ static void kb_event_cb(lv_obj_t * event_kb, lv_event_t event)
if(strlen(ssid) > 0 && wifiValidateSsid(ssid, pass)) {
wifiSetConfig(settings.as<JsonObject>());
Log.notice(TAG_OOBE, F(D_OOBE_SSID_VALIDATED), ssid);
LOG_TRACE(TAG_OOBE, F(D_OOBE_SSID_VALIDATED), ssid);
dispatch_reboot(true);
}
@ -247,7 +247,7 @@ static void oobeSetupSsid(void)
/* Create a label and position it above the text box */
lv_obj_t * pwd_label = lv_label_create(oobepage[1], NULL);
snprintf_P(buffer, sizeof(buffer), PSTR("Password:"));
snprintf_P(buffer, sizeof(buffer), PSTR(D_TELNET_PASSWORD));
lv_label_set_text(pwd_label, buffer);
lv_obj_align(pwd_label, pwd_ta, labelpos, 0, 0);
@ -324,10 +324,10 @@ bool oobeSetup()
lv_obj_set_click(lv_disp_get_layer_sys(NULL), true);
if(oobeAutoCalibrate) {
lv_obj_set_event_cb(lv_disp_get_layer_sys(NULL), oobe_calibrate_cb);
Log.trace(TAG_OOBE, F(D_OOBE_AUTO_CALIBRATE));
LOG_INFO(TAG_OOBE, F(D_OOBE_AUTO_CALIBRATE));
} else {
lv_obj_set_event_cb(lv_disp_get_layer_sys(NULL), gotoPage1_cb);
Log.trace(TAG_OOBE, F(D_OOBE_CALIBRATED));
LOG_INFO(TAG_OOBE, F(D_OOBE_CALIBRATED));
}
oobeSetPage(0);
return true;
@ -355,9 +355,9 @@ void oobeFakeSetup(const char *, const char *)
if(oobeAutoCalibrate) {
lv_obj_set_click(lv_disp_get_layer_sys(NULL), true);
lv_obj_set_event_cb(lv_disp_get_layer_sys(NULL), oobe_calibrate_cb);
Log.trace(TAG_OOBE, F(D_OOBE_AUTO_CALIBRATE));
LOG_INFO(TAG_OOBE, F(D_OOBE_AUTO_CALIBRATE));
} else {
Log.trace(TAG_OOBE, F(D_OOBE_CALIBRATED));
LOG_INFO(TAG_OOBE, F(D_OOBE_CALIBRATED));
}
#endif
}

18
src/net/hasp_ethernet_esp32.cpp
View File

@ -15,32 +15,32 @@ void EthernetEvent(WiFiEvent_t event)
{
switch(event) {
case SYSTEM_EVENT_ETH_START:
Log.notice(TAG_ETH, F(D_SERVICE_STARTED));
LOG_TRACE(TAG_ETH, F(D_SERVICE_STARTED));
// set eth hostname here
ETH.setHostname(mqttGetNodename().c_str());
break;
case SYSTEM_EVENT_ETH_CONNECTED:
Log.notice(TAG_ETH, F(D_SERVICE_CONNECTED));
LOG_TRACE(TAG_ETH, F(D_SERVICE_CONNECTED));
eth_connected = true;
break;
case SYSTEM_EVENT_ETH_GOT_IP:
Log.notice(TAG_ETH, F("MAC Address %s"), ETH.macAddress().c_str());
LOG_TRACE(TAG_ETH, F("MAC Address %s"), ETH.macAddress().c_str());
ip = ETH.localIP();
Log.notice(TAG_ETH, F("IPv4: %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
LOG_TRACE(TAG_ETH, F("IPv4: %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
if(ETH.fullDuplex()) {
Log.notice(TAG_ETH, F("FULL_DUPLEX"));
LOG_TRACE(TAG_ETH, F("FULL_DUPLEX"));
}
Log.notice(TAG_ETH, F("LINK_SPEED %d Mbps"), ETH.linkSpeed());
LOG_TRACE(TAG_ETH, F("LINK_SPEED %d Mbps"), ETH.linkSpeed());
eth_connected = true;
networkStart(); // Start network services
break;
case SYSTEM_EVENT_ETH_DISCONNECTED:
Log.notice(TAG_ETH, F(D_SERVICE_DISCONNECTED));
LOG_TRACE(TAG_ETH, F(D_SERVICE_DISCONNECTED));
eth_connected = false;
networkStop(); // Stop network services
break;
case SYSTEM_EVENT_ETH_STOP:
Log.warning(TAG_ETH, F(D_SERVICE_STOPPED));
LOG_WARNING(TAG_ETH, F(D_SERVICE_STOPPED));
eth_connected = false;
break;
default:
@ -59,7 +59,7 @@ void ethernetLoop(void)
bool ethernetEvery5Seconds()
{
// Log.warning(TAG_ETH, eth_connected ? F(D_NETWORK_ONLINE) : F(D_NETWORK_OFFLINE));
// LOG_WARNING(TAG_ETH, eth_connected ? F(D_NETWORK_ONLINE) : F(D_NETWORK_OFFLINE));
return eth_connected;
}

24
src/net/hasp_ethernet_stm32.cpp
View File

@ -15,17 +15,17 @@ void ethernetSetup()
{
#if USE_BUILTIN_ETHERNET > 0
// start Ethernet and UDP
Log.notice(TAG_ETH, F("LAN8720 "D_SERVICE_STARTING));
LOG_TRACE(TAG_ETH, F("LAN8720 "D_SERVICE_STARTING));
if(Ethernet.begin() == 0) {
Log.notice(TAG_ETH, F("Failed to configure Ethernet using DHCP"));
LOG_TRACE(TAG_ETH, F("Failed to configure Ethernet using DHCP"));
eth_connected = false;
} else {
ip = Ethernet.localIP();
Log.notice(TAG_ETH, F("DHCP Success got IP %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
LOG_TRACE(TAG_ETH, F("DHCP Success got IP %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
eth_connected = true;
}
Log.notice(TAG_ETH, F("MAC Address %s"), halGetMacAddress(0, ":"));
LOG_TRACE(TAG_ETH, F("MAC Address %s"), halGetMacAddress(0, ":"));
#else
byte mac[6];
@ -44,12 +44,12 @@ void ethernetSetup()
Ethernet.setCsPin(W5500_CS);
Ethernet.setRstPin(W5500_RST);
Ethernet.setHostname(ethHostname);
Log.notice(TAG_ETH, F("W5500 "D_SERVICE_STARTING));
LOG_TRACE(TAG_ETH, F("W5500 "D_SERVICE_STARTING));
if(Ethernet.begin(mac) == 0) {
Log.notice(TAG_ETH, F("Failed to configure Ethernet using DHCP"));
LOG_TRACE(TAG_ETH, F("Failed to configure Ethernet using DHCP"));
} else {
ip = Ethernet.localIP();
Log.notice(TAG_ETH, F("DHCP Success got IP %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
LOG_TRACE(TAG_ETH, F("DHCP Success got IP %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
}
#endif
}
@ -59,24 +59,24 @@ void ethernetLoop(void)
switch(Ethernet.maintain()) {
case 1:
// renewed fail
Log.error(TAG_ETH, F("Error: renewed fail"));
LOG_ERROR(TAG_ETH, F("Error: renewed fail"));
break;
case 2:
// renewed success
ip = Ethernet.localIP();
Log.notice(TAG_ETH, F("DHCP Renew Success got IP=%d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
LOG_TRACE(TAG_ETH, F("DHCP Renew Success got IP=%d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
break;
case 3:
// rebind fail
Log.error(TAG_ETH, F("Error: rebind fail"));
LOG_ERROR(TAG_ETH, F("Error: rebind fail"));
break;
case 4:
// rebind success
ip = Ethernet.localIP();
Log.notice(TAG_ETH, F("DHCP Rebind Success got IP=%d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
LOG_TRACE(TAG_ETH, F("DHCP Rebind Success got IP=%d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
break;
default:
@ -93,7 +93,7 @@ bool ethernetEvery5Seconds()
#else
state = Ethernet.link() == 1;
#endif
Log.warning(TAG_ETH, state ? F(D_NETWORK_ONLINE) : F(D_NETWORK_OFFLINE));
LOG_WARNING(TAG_ETH, state ? F(D_NETWORK_ONLINE) : F(D_NETWORK_OFFLINE));
return state;
}

40
src/net/hasp_wifi.cpp
View File

@ -60,12 +60,12 @@ static void wifiConnected(IPAddress ipaddress)
#if defined(STM32F4xx)
IPAddress ip;
ip = WiFi.localIP();
Log.notice(TAG_WIFI, F("Received IP address %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
LOG_TRACE(TAG_WIFI, F("Received IP address %d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
#else
Log.notice(TAG_WIFI, F(D_NETWORK_IP_ADDRESS_RECEIVED), ipaddress.toString().c_str());
LOG_TRACE(TAG_WIFI, F(D_NETWORK_IP_ADDRESS_RECEIVED), ipaddress.toString().c_str());
#endif
Log.verbose(TAG_WIFI, F("Connected = %s"), WiFi.status() == WL_CONNECTED ? PSTR(D_NETWORK_ONLINE) : PSTR(D_NETWORK_OFFLINE));
LOG_VERBOSE(TAG_WIFI, F("Connected = %s"), WiFi.status() == WL_CONNECTED ? PSTR(D_NETWORK_ONLINE) : PSTR(D_NETWORK_OFFLINE));
networkStart();
}
@ -77,7 +77,7 @@ static void wifiDisconnected(const char * ssid, uint8_t reason)
// networkStop();
if(wifiReconnectCounter > 33) {
Log.error(TAG_WIFI, F("Retries exceed %u: Rebooting..."), wifiReconnectCounter);
LOG_ERROR(TAG_WIFI, F("Retries exceed %u: Rebooting..."), wifiReconnectCounter);
dispatch_reboot(false);
}
@ -267,12 +267,12 @@ static void wifiDisconnected(const char * ssid, uint8_t reason)
snprintf_P(buffer, sizeof(buffer), PSTR("unknown"));
}
Log.warning(TAG_WIFI, F("Disconnected from %s (Reason: %s [%d])"), ssid, buffer, reason);
LOG_WARNING(TAG_WIFI, F("Disconnected from %s (Reason: %s [%d])"), ssid, buffer, reason);
}
static void wifiSsidConnected(const char * ssid)
{
Log.notice(TAG_WIFI, F("Connected to SSID %s. Requesting IP..."), ssid);
LOG_TRACE(TAG_WIFI, F("Connected to SSID %s. Requesting IP..."), ssid);
wifiReconnectCounter = 0;
}
@ -334,7 +334,7 @@ bool wifiShowAP(char * ssid, char * pass)
sprintf_P(ssid, PSTR("HASP-%02x%02x%02x"), mac[3], mac[4], mac[5]);
sprintf_P(pass, PSTR("haspadmin"));
#if defined(STM32F4xx)
Log.warning(TAG_WIFI, F("We should setup Temporary Access Point %s password: %s"), ssid, pass);
LOG_WARNING(TAG_WIFI, F("We should setup Temporary Access Point %s password: %s"), ssid, pass);
#else
WiFi.softAP(ssid, pass);
@ -342,8 +342,8 @@ bool wifiShowAP(char * ssid, char * pass)
// dnsServer.setErrorReplyCode(DNSReplyCode::NoError);
// dnsServer.start(DNS_PORT, "*", apIP);
Log.warning(TAG_WIFI, F("Temporary Access Point %s password: %s"), ssid, pass);
Log.warning(TAG_WIFI, F("AP IP address : %s"), WiFi.softAPIP().toString().c_str());
LOG_WARNING(TAG_WIFI, F("Temporary Access Point %s password: %s"), ssid, pass);
LOG_WARNING(TAG_WIFI, F("AP IP address : %s"), WiFi.softAPIP().toString().c_str());
// httpReconnect();}
#endif
return true;
@ -379,14 +379,14 @@ void wifiSetup()
// check for the presence of the shield:
if(WiFiSpi.status() == WL_NO_SHIELD) {
Log.fatal(TAG_WIFI, F("WiFi shield not present"));
LOG_FATAL(TAG_WIFI, F("WiFi shield not present"));
// don't continue:
while(true)
;
}
if(!WiFiSpi.checkProtocolVersion()) {
Log.fatal(TAG_WIFI, F("Protocol version mismatch. Please upgrade the firmware"));
LOG_FATAL(TAG_WIFI, F("Protocol version mismatch. Please upgrade the firmware"));
// don't continue:
while(true)
;
@ -396,7 +396,7 @@ void wifiSetup()
// int status = WL_IDLE_STATUS; // the Wifi radio's status
if(!wifiShowAP()) {
// while (status != WL_CONNECTED) {
Log.notice(TAG_WIFI, F("Connecting to : %s"), wifiSsid);
LOG_TRACE(TAG_WIFI, F("Connecting to : %s"), wifiSsid);
// Connect to WPA/WPA2 network
// status = WiFi.begin(wifiSsid, wifiPassword);
WiFi.begin(wifiSsid, wifiPassword);
@ -420,7 +420,7 @@ void wifiSetup()
#endif
wifiReconnect();
Log.notice(TAG_WIFI, F("Connecting to : %s"), wifiSsid);
LOG_TRACE(TAG_WIFI, F("Connecting to : %s"), wifiSsid);
}
#endif
}
@ -440,10 +440,10 @@ bool wifiEvery5Seconds()
} else {
wifiReconnectCounter++;
if(wifiReconnectCounter > 45) {
Log.error(TAG_WIFI, F("Retries exceed %u: Rebooting..."), wifiReconnectCounter);
LOG_ERROR(TAG_WIFI, F("Retries exceed %u: Rebooting..."), wifiReconnectCounter);
dispatch_reboot(false);
}
Log.warning(TAG_WIFI, F("No Connection... retry %u"), wifiReconnectCounter);
LOG_WARNING(TAG_WIFI, F("No Connection... retry %u"), wifiReconnectCounter);
if(wifiReconnectCounter % 6 == 0) {
wifiReconnect();
}
@ -467,18 +467,18 @@ bool wifiValidateSsid(const char * ssid, const char * pass)
while(attempt < 15 && (WiFi.status() != WL_CONNECTED || WiFi.localIP().toString() == F("0.0.0.0"))) {
#endif
attempt++;
Log.trace(TAG_WIFI, F("Trying to connect to %s... %u"), wifiSsid, attempt);
LOG_INFO(TAG_WIFI, F("Trying to connect to %s... %u"), wifiSsid, attempt);
delay(500);
}
#if defined(STM32F4xx)
Log.trace(TAG_WIFI, F(D_NETWORK_IP_ADDRESS_RECEIVED), espIp);
LOG_INFO(TAG_WIFI, F(D_NETWORK_IP_ADDRESS_RECEIVED), espIp);
if((WiFi.status() == WL_CONNECTED && String(espIp) != F("0.0.0.0"))) return true;
#else
Log.trace(TAG_WIFI, F(D_NETWORK_IP_ADDRESS_RECEIVED), WiFi.localIP().toString().c_str());
LOG_INFO(TAG_WIFI, F(D_NETWORK_IP_ADDRESS_RECEIVED), WiFi.localIP().toString().c_str());
if((WiFi.status() == WL_CONNECTED && WiFi.localIP().toString() != F("0.0.0.0"))) return true;
#endif
Log.warning(TAG_WIFI, F(D_NETWORK_IP_ADDRESS_RECEIVED), WiFi.localIP().toString().c_str());
LOG_WARNING(TAG_WIFI, F(D_NETWORK_IP_ADDRESS_RECEIVED), WiFi.localIP().toString().c_str());
WiFi.disconnect();
return false;
}
@ -490,7 +490,7 @@ void wifiStop()
#if !defined(STM32F4xx)
WiFi.mode(WIFI_OFF);
#endif
Log.warning(TAG_WIFI, F(D_SERVICE_STOPPED));
LOG_WARNING(TAG_WIFI, F(D_SERVICE_STOPPED));
}
void wifi_get_statusupdate(char * buffer, size_t len)

54
src/svc/hasp_http.cpp
View File

@ -186,10 +186,10 @@ bool httpIsAuthenticated(const __FlashStringHelper * fstr_page)
}
#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
Log.notice(TAG_HTTP, F("Sending %S page to client connected from: %s"), fstr_page,
LOG_TRACE(TAG_HTTP, F("Sending %S page to client connected from: %s"), fstr_page,
webServer.client().remoteIP().toString().c_str());
#else
// Log.trace(TAG_HTTP,F("Sending %s page to client connected from: %s"), page,
// LOG_INFO(TAG_HTTP,F("Sending %s page to client connected from: %s"), page,
// String(webServer.client().remoteIP()).c_str());
#endif
@ -231,7 +231,7 @@ void webSendPage(char * nodename, uint32_t httpdatalength, bool gohome = false)
contentLength += sizeof(HTTP_FOOTER) - 1;
if(httpdatalength > HTTP_PAGE_SIZE) {
Log.warning(TAG_HTTP, F("Sending page with %u static and %u dynamic bytes"), contentLength, httpdatalength);
LOG_WARNING(TAG_HTTP, F("Sending page with %u static and %u dynamic bytes"), contentLength, httpdatalength);
}
webServer.setContentLength(contentLength + httpdatalength);
@ -761,7 +761,7 @@ void webUploadProgress()
{
long t = webServer.header("Content-Length").toInt();
if(millis() - htppLastLoopTime >= 1250) {
Log.verbose(TAG_HTTP, F(D_BULLET "Uploaded %u / %d bytes"), upload->totalSize + upload->currentSize, t);
LOG_VERBOSE(TAG_HTTP, F(D_BULLET "Uploaded %u / %d bytes"), upload->totalSize + upload->currentSize, t);
htppLastLoopTime = millis();
}
if(t > 0) t = (upload->totalSize + upload->currentSize) * 100 / t;
@ -776,17 +776,17 @@ static inline void webUpdatePrintError()
output.reserve(128);
StringStream stream((String &)output);
Update.printError(stream); // ESP8266 only has printError()
Log.error(TAG_HTTP, output.c_str());
LOG_ERROR(TAG_HTTP, output.c_str());
haspProgressMsg(output.c_str());
#elif defined(ARDUINO_ARCH_ESP32)
Log.error(TAG_HTTP, Update.errorString()); // ESP32 has errorString()
LOG_ERROR(TAG_HTTP, Update.errorString()); // ESP32 has errorString()
haspProgressMsg(Update.errorString());
#endif
}
void webUpdateReboot()
{
Log.trace(TAG_HTTP, F("Update Success: %u bytes received. Rebooting..."), upload->totalSize);
LOG_INFO(TAG_HTTP, F("Update Success: %u bytes received. Rebooting..."), upload->totalSize);
{
String httpMessage((char *)0);
@ -812,7 +812,7 @@ void webHandleFirmwareUpload()
if(upload->status == UPLOAD_FILE_START) {
if(!httpIsAuthenticated(F("update"))) return;
Log.notice(TAG_HTTP, F("Update: %s"), upload->filename.c_str());
LOG_TRACE(TAG_HTTP, F("Update: %s"), upload->filename.c_str());
haspProgressMsg(upload->filename.c_str());
// WiFiUDP::stopAll();
uint32_t maxSketchSpace = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
@ -874,7 +874,7 @@ void handleFileUpload()
upload = &webServer.upload();
if(upload->status == UPLOAD_FILE_START) {
if(!httpIsAuthenticated(F("fileupload"))) return;
Log.trace(TAG_HTTP, F("Total size: %s"), webServer.headerName(0).c_str());
LOG_INFO(TAG_HTTP, F("Total size: %s"), webServer.headerName(0).c_str());
String filename((char *)0);
filename.reserve(128);
filename = upload->filename;
@ -884,23 +884,23 @@ void handleFileUpload()
}
if(filename.length() < 32) {
fsUploadFile = HASP_FS.open(filename, "w");
Log.notice(TAG_HTTP, F("handleFileUpload Name: %s"), filename.c_str());
LOG_TRACE(TAG_HTTP, F("handleFileUpload Name: %s"), filename.c_str());
haspProgressMsg(fsUploadFile.name());
} else {
Log.error(TAG_HTTP, F("Filename %s is too long"), filename.c_str());
LOG_ERROR(TAG_HTTP, F("Filename %s is too long"), filename.c_str());
}
} else if(upload->status == UPLOAD_FILE_WRITE) {
// DBG_OUTPUT_PORT.print("handleFileUpload Data: "); debugPrintln(upload.currentSize);
if(fsUploadFile) {
if(fsUploadFile.write(upload->buf, upload->currentSize) != upload->currentSize) {
Log.error(TAG_HTTP, F("Failed to write received data to file"));
LOG_ERROR(TAG_HTTP, F("Failed to write received data to file"));
} else {
webUploadProgress(); // Moved to httpEverySecond Loop
}
}
} else if(upload->status == UPLOAD_FILE_END) {
if(fsUploadFile) {
Log.trace(TAG_HTTP, F("Uploaded %s (%u bytes)"), fsUploadFile.name(), upload->totalSize);
LOG_INFO(TAG_HTTP, F("Uploaded %s (%u bytes)"), fsUploadFile.name(), upload->totalSize);
fsUploadFile.close();
}
haspProgressVal(255);
@ -923,7 +923,7 @@ void handleFileDelete()
return webServer.send_P(500, mimetype, PSTR("BAD ARGS"));
}
String path = webServer.arg(0);
Log.notice(TAG_HTTP, F("handleFileDelete: %s"), path.c_str());
LOG_TRACE(TAG_HTTP, F("handleFileDelete: %s"), path.c_str());
if(path == "/") {
return webServer.send_P(500, mimetype, PSTR("BAD PATH"));
}
@ -943,7 +943,7 @@ void handleFileCreate()
return webServer.send(500, PSTR("text/plain"), PSTR("BAD ARGS"));
}
String path = webServer.arg(0);
Log.notice(TAG_HTTP, F("handleFileCreate: %s"), path.c_str());
LOG_TRACE(TAG_HTTP, F("handleFileCreate: %s"), path.c_str());
if(path == "/") {
return webServer.send(500, PSTR("text/plain"), PSTR("BAD PATH"));
}
@ -970,7 +970,7 @@ void handleFileList()
}
String path = webServer.arg(F("dir"));
Log.notice(TAG_HTTP, F("handleFileList: %s"), path.c_str());
LOG_TRACE(TAG_HTTP, F("handleFileList: %s"), path.c_str());
path.clear();
#if defined(ARDUINO_ARCH_ESP32)
@ -1752,10 +1752,10 @@ void httpHandleNotFound()
#endif
#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
Log.notice(TAG_HTTP, F("Sending 404 to client connected from: %s"),
LOG_TRACE(TAG_HTTP, F("Sending 404 to client connected from: %s"),
webServer.client().remoteIP().toString().c_str());
#else
// Log.notice(TAG_HTTP,F("Sending 404 to client connected from: %s"), String(webServer.client().remoteIP()).c_str());
// LOG_TRACE(TAG_HTTP,F("Sending 404 to client connected from: %s"), String(webServer.client().remoteIP()).c_str());
#endif
String httpMessage((char *)0);
@ -1824,7 +1824,7 @@ void httpHandleEspFirmware()
}
webSendFooter();
Log.notice(TAG_HTTP, F("Attempting ESP firmware update from: %s"), webServer.arg("espFirmware").c_str());
LOG_TRACE(TAG_HTTP, F("Attempting ESP firmware update from: %s"), webServer.arg("espFirmware").c_str());
// espStartOta(webServer.arg("espFirmware"));
}
@ -1898,9 +1898,9 @@ void httpStart()
#if defined(STM32F4xx)
IPAddress ip;
ip = WiFi.localIP();
Log.trace(TAG_HTTP, F(D_SERVICE_STARTED " @ http://%d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
LOG_INFO(TAG_HTTP, F(D_SERVICE_STARTED " @ http://%d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
#else
Log.trace(TAG_HTTP, F(D_SERVICE_STARTED " @ http://%s"),
LOG_INFO(TAG_HTTP, F(D_SERVICE_STARTED " @ http://%s"),
(WiFi.getMode() != WIFI_STA ? WiFi.softAPIP().toString().c_str() : WiFi.localIP().toString().c_str()));
#endif
#else
@ -1910,7 +1910,7 @@ void httpStart()
#else
ip = Ethernet.localIP();
#endif
Log.trace(TAG_HTTP, F(D_SERVICE_STARTED " @ http://%d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
LOG_INFO(TAG_HTTP, F(D_SERVICE_STARTED " @ http://%d.%d.%d.%d"), ip[0], ip[1], ip[2], ip[3]);
#endif
}
@ -1918,7 +1918,7 @@ void httpStop()
{
webServer.stop();
webServerStarted = false;
Log.warning(TAG_HTTP, F(D_SERVICE_STOPPED));
LOG_WARNING(TAG_HTTP, F(D_SERVICE_STOPPED));
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@ -1940,7 +1940,7 @@ void httpSetup()
#if HASP_USE_CONFIG > 0
if(WiFi.getMode() != WIFI_STA) {
Log.notice(TAG_HTTP, F("Wifi access point"));
LOG_TRACE(TAG_HTTP, F("Wifi access point"));
webServer.on(F("/"), webHandleWifiConfig);
return;
}
@ -1973,7 +1973,7 @@ void httpSetup()
F("/edit"), HTTP_POST,
[]() {
webServer.send(200, "text/plain", "");
Log.verbose(TAG_HTTP, F("Headers: %d"), webServer.headers());
LOG_VERBOSE(TAG_HTTP, F("Headers: %d"), webServer.headers());
},
handleFileUpload);
#endif
@ -2009,13 +2009,13 @@ void httpSetup()
F("/update"), HTTP_POST,
[]() {
webServer.send(200, "text/plain", "");
Log.verbose(TAG_HTTP, F("Total size: %s"), webServer.hostHeader().c_str());
LOG_VERBOSE(TAG_HTTP, F("Total size: %s"), webServer.hostHeader().c_str());
},
webHandleFirmwareUpload);
webServer.on(F("/espfirmware"), httpHandleEspFirmware);
#endif
Log.trace(TAG_HTTP, F(D_SERVICE_STARTED));
LOG_INFO(TAG_HTTP, F(D_SERVICE_STARTED));
// webStart(); Wait for network connection
}

12
src/svc/hasp_mdns.cpp
View File

@ -27,11 +27,11 @@ void mdnsSetup()
void mdnsStart()
{
if(!mdns_config.enable) {
Log.notice(TAG_MDNS, F(D_SERVICE_DISABLED));
LOG_TRACE(TAG_MDNS, F(D_SERVICE_DISABLED));
return;
}
Log.notice(TAG_MDNS, F(D_SERVICE_STARTING));
LOG_TRACE(TAG_MDNS, F(D_SERVICE_STARTING));
#if HASP_USE_MQTT > 0
String hasp2Node = mqttGetNodename();
@ -44,7 +44,7 @@ void mdnsStart()
/* uint8_t attempt = 0;
while(!MDNS.begin(hasp2Node.c_str())) {
if(attempt++ >= 3) {
Log.error(TAG_MDNS, F(D_SERVICE_START_FAILED ": %s"), hasp2Node.c_str());
LOG_ERROR(TAG_MDNS, F(D_SERVICE_START_FAILED ": %s"), hasp2Node.c_str());
return;
}
@ -52,7 +52,7 @@ void mdnsStart()
hasp2Node = mqttGetNodename();
hasp2Node += F("_");
hasp2Node += String(attempt);
Log.verbose(TAG_MDNS, F("Trying hostname %s"), hasp2Node.c_str());
LOG_VERBOSE(TAG_MDNS, F("Trying hostname %s"), hasp2Node.c_str());
};*/
if(MDNS.begin(hasp2Node.c_str())) {
@ -78,9 +78,9 @@ void mdnsStart()
MDNS.addService(service, proto, 23);
// }
Log.trace(TAG_MDNS, F(D_SERVICE_STARTED));
LOG_INFO(TAG_MDNS, F(D_SERVICE_STARTED));
} else {
Log.error(TAG_MDNS, F(D_SERVICE_START_FAILED));
LOG_ERROR(TAG_MDNS, F(D_SERVICE_START_FAILED));
}
}

54
src/svc/hasp_mqtt.cpp
View File

@ -94,13 +94,13 @@ static bool mqttPublish(const char * topic, const char * payload, size_t len, bo
mqttClient.write((uint8_t *)payload, len);
mqttClient.endPublish();
Log.notice(TAG_MQTT_PUB, F("%s => %s"), topic, payload);
LOG_TRACE(TAG_MQTT_PUB, F("%s => %s"), topic, payload);
return true;
} else {
Log.error(TAG_MQTT_PUB, F(D_MQTT_FAILED " %s => %s"), topic, payload);
LOG_ERROR(TAG_MQTT_PUB, F(D_MQTT_FAILED " %s => %s"), topic, payload);
}
} else {
Log.error(TAG_MQTT, F(D_MQTT_NOT_CONNECTED));
LOG_ERROR(TAG_MQTT, F(D_MQTT_NOT_CONNECTED));
}
return false;
}
@ -149,13 +149,13 @@ void mqtt_send_state(const __FlashStringHelper * subtopic, const char * payload)
static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
{ // Handle incoming commands from MQTT
if(length + 1 >= mqttClient.getBufferSize()) {
Log.error(TAG_MQTT_RCV, F("Payload too long (%d bytes)"), length);
LOG_ERROR(TAG_MQTT_RCV, F("Payload too long (%d bytes)"), length);
return;
} else {
payload[length] = '\0';
}
Log.notice(TAG_MQTT_RCV, F("%s = %s"), topic, (char *)payload);
LOG_TRACE(TAG_MQTT_RCV, F("%s = %s"), topic, (char *)payload);
if(topic == strstr(topic, mqttNodeTopic)) { // startsWith mqttNodeTopic
@ -178,7 +178,7 @@ static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
} else {
// Other topic
Log.error(TAG_MQTT, F(D_MQTT_INVALID_TOPIC));
LOG_ERROR(TAG_MQTT, F(D_MQTT_INVALID_TOPIC));
return;
}
@ -195,7 +195,7 @@ static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
}
} else {
// Log.notice(TAG_MQTT, F("ignoring LWT = online"));
// LOG_TRACE(TAG_MQTT, F("ignoring LWT = online"));
}
} else {
dispatch_topic_payload(topic, (const char *)payload);
@ -207,9 +207,9 @@ static void mqttSubscribeTo(const __FlashStringHelper * format, const char * dat
char tmp_topic[strlen_P((PGM_P)format) + 2 + strlen(data)];
snprintf_P(tmp_topic, sizeof(tmp_topic), (PGM_P)format, data);
if(mqttClient.subscribe(tmp_topic)) {
Log.verbose(TAG_MQTT, F(D_BULLET D_MQTT_SUBSCRIBED), tmp_topic);
LOG_VERBOSE(TAG_MQTT, F(D_BULLET D_MQTT_SUBSCRIBED), tmp_topic);
} else {
Log.error(TAG_MQTT, F(D_MQTT_NOT_SUBSCRIBED), tmp_topic);
LOG_ERROR(TAG_MQTT, F(D_MQTT_NOT_SUBSCRIBED), tmp_topic);
}
}
@ -230,7 +230,7 @@ void mqttStart()
mac.toLowerCase();
memset(mqttClientId, 0, sizeof(mqttClientId));
snprintf_P(mqttClientId, sizeof(mqttClientId), PSTR(D_MQTT_DEFAULT_NAME), mac.c_str());
Log.trace(TAG_MQTT, mqttClientId);
LOG_INFO(TAG_MQTT, mqttClientId);
}
// Attempt to connect and set LWT and Clean Session
@ -245,13 +245,13 @@ void mqttStart()
switch(mqttClient.state()) {
case MQTT_CONNECTION_TIMEOUT:
Log.warning(TAG_MQTT, F("Connection timeout"));
LOG_WARNING(TAG_MQTT, F("Connection timeout"));
break;
case MQTT_CONNECTION_LOST:
Log.warning(TAG_MQTT, F("Connection lost"));
LOG_WARNING(TAG_MQTT, F("Connection lost"));
break;
case MQTT_CONNECT_FAILED:
Log.warning(TAG_MQTT, F("Connection failed"));
LOG_WARNING(TAG_MQTT, F("Connection failed"));
break;
case MQTT_DISCONNECTED:
snprintf_P(buffer, sizeof(buffer), PSTR(D_MQTT_DISCONNECTED));
@ -259,32 +259,32 @@ void mqttStart()
case MQTT_CONNECTED:
break;
case MQTT_CONNECT_BAD_PROTOCOL:
Log.warning(TAG_MQTT, F("MQTT version not suported"));
LOG_WARNING(TAG_MQTT, F("MQTT version not suported"));
break;
case MQTT_CONNECT_BAD_CLIENT_ID:
Log.warning(TAG_MQTT, F("Client ID rejected"));
LOG_WARNING(TAG_MQTT, F("Client ID rejected"));
break;
case MQTT_CONNECT_UNAVAILABLE:
Log.warning(TAG_MQTT, F("Server unavailable"));
LOG_WARNING(TAG_MQTT, F("Server unavailable"));
break;
case MQTT_CONNECT_BAD_CREDENTIALS:
Log.warning(TAG_MQTT, F("Bad credentials"));
LOG_WARNING(TAG_MQTT, F("Bad credentials"));
break;
case MQTT_CONNECT_UNAUTHORIZED:
Log.warning(TAG_MQTT, F("Unauthorized"));
LOG_WARNING(TAG_MQTT, F("Unauthorized"));
break;
default:
Log.warning(TAG_MQTT, F("Unknown failure"));
LOG_WARNING(TAG_MQTT, F("Unknown failure"));
}
if(mqttReconnectCount > 20) {
Log.error(TAG_MQTT, F("Retry count exceeded, rebooting..."));
LOG_ERROR(TAG_MQTT, F("Retry count exceeded, rebooting..."));
dispatch_reboot(false);
}
return;
}
Log.trace(TAG_MQTT, F(D_MQTT_CONNECTED), mqttServer, mqttClientId);
LOG_INFO(TAG_MQTT, F(D_MQTT_CONNECTED), mqttServer, mqttClientId);
// Subscribe to our incoming topics
const __FlashStringHelper * F_topic;
@ -323,12 +323,12 @@ void mqttSetup()
mqttClient.setServer(mqttServer, mqttPort);
mqttClient.setCallback(mqtt_message_cb);
// if(!mqttClient.setBufferSize(1024)) {
// Log.error(TAG_MQTT, F("Buffer allocation failed"));
// LOG_ERROR(TAG_MQTT, F("Buffer allocation failed"));
// } else {
Log.trace(TAG_MQTT, F(D_MQTT_STARTED), mqttClient.getBufferSize());
LOG_INFO(TAG_MQTT, F(D_MQTT_STARTED), mqttClient.getBufferSize());
// }
} else {
Log.warning(TAG_MQTT, F(D_MQTT_NOT_CONFIGURED));
LOG_WARNING(TAG_MQTT, F(D_MQTT_NOT_CONFIGURED));
}
}
@ -340,7 +340,7 @@ void mqttLoop(void)
void mqttEvery5Seconds(bool networkIsConnected)
{
if(mqttEnabled && networkIsConnected && !mqttClient.connected()) {
Log.notice(TAG_MQTT, F(D_MQTT_RECONNECTING));
LOG_TRACE(TAG_MQTT, F(D_MQTT_RECONNECTING));
mqttStart();
}
}
@ -353,10 +353,10 @@ String mqttGetNodename()
void mqttStop()
{
if(mqttEnabled && mqttClient.connected()) {
Log.notice(TAG_MQTT, F(D_MQTT_DISCONNECTING));
LOG_TRACE(TAG_MQTT, F(D_MQTT_DISCONNECTING));
mqtt_send_lwt(false);
mqttClient.disconnect();
Log.trace(TAG_MQTT, F(D_MQTT_DISCONNECTED));
LOG_INFO(TAG_MQTT, F(D_MQTT_DISCONNECTED));
}
}

4
src/svc/hasp_mqtt_ha.cpp
View File

@ -34,7 +34,7 @@ const char FP_MQTT_HA_MANUFACTURER[] PROGMEM = "mf";
void mqtt_ha_send_json(char * topic, JsonDocument & doc)
{
Log.verbose(TAG_MQTT_PUB, topic);
LOG_VERBOSE(TAG_MQTT_PUB, topic);
mqttClient.beginPublish(topic, measureJson(doc), RETAINED);
serializeJson(doc, mqttClient);
mqttClient.endPublish();
@ -241,7 +241,7 @@ void mqtt_ha_register_activepage()
void mqtt_ha_register_auto_discovery()
{
Log.notice(TAG_MQTT_PUB, F(D_MQTT_HA_AUTO_DISCOVERY));
LOG_TRACE(TAG_MQTT_PUB, F(D_MQTT_HA_AUTO_DISCOVERY));
mqtt_ha_register_activepage();
// mqtt_ha_register_button(0, 1);
// mqtt_ha_register_button(0, 2);

26
src/svc/hasp_ota.cpp
View File

@ -32,7 +32,7 @@ bool otaUpdateCheck()
{ // firmware update check
WiFiClientSecure wifiUpdateClientSecure;
HTTPClient updateClient;
Log.notice(TAG_OTA, F(D_OTA_CHECK_UPDATE), otaUrl.c_str());
LOG_TRACE(TAG_OTA, F(D_OTA_CHECK_UPDATE), otaUrl.c_str());
// wifiUpdateClientSecure.setInsecure();
// wifiUpdateClientSecure.setBufferSizes(512, 512);
@ -40,7 +40,7 @@ bool otaUpdateCheck()
int httpCode = updateClient.GET(); // start connection and send HTTP header
if(httpCode != HTTP_CODE_OK) {
Log.error(TAG_OTA, F(D_OTA_CHECK_FAILED), updateClient.errorToString(httpCode).c_str());
LOG_ERROR(TAG_OTA, F(D_OTA_CHECK_FAILED), updateClient.errorToString(httpCode).c_str());
return false;
}
@ -65,14 +65,14 @@ bool otaUpdateCheck()
// debugPrintln(String(F("UPDATE: New ESP version available: ")) + String(updateEspAvailableVersion));
// }
}
Log.verbose(TAG_OTA, F(D_OTA_CHECK_COMPLETE));
LOG_VERBOSE(TAG_OTA, F(D_OTA_CHECK_COMPLETE));
}
return true;
}
static inline void otaProgress(void)
{
Log.verbose(TAG_OTA, F("%s update in progress... %3u%"),
LOG_VERBOSE(TAG_OTA, F("%s update in progress... %3u%"),
(ArduinoOTA.getCommand() == U_FLASH ? PSTR("Firmware") : PSTR("Filesystem")), otaPrecentageComplete);
}
@ -87,7 +87,7 @@ void otaOnProgress(unsigned int progress, unsigned int total)
void otaSetup(void)
{
if(strlen(otaUrl.c_str())) {
Log.trace(TAG_OTA, otaUrl.c_str());
LOG_INFO(TAG_OTA, otaUrl.c_str());
}
if(otaPort > 0) {
@ -97,14 +97,14 @@ void otaSetup(void)
// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
}
Log.notice(TAG_OTA, F(D_SERVICE_STARTING));
LOG_TRACE(TAG_OTA, F(D_SERVICE_STARTING));
haspProgressMsg(F(D_OTA_UPDATE_FIRMWARE));
haspProgressVal(0);
otaPrecentageComplete = 0;
});
ArduinoOTA.onEnd([]() {
otaPrecentageComplete = 100;
Log.notice(TAG_OTA, F(D_OTA_UPDATE_COMPLETE));
LOG_TRACE(TAG_OTA, F(D_OTA_UPDATE_COMPLETE));
haspProgressVal(100);
haspProgressMsg(F(D_OTA_UPDATE_APPLY));
otaProgress();
@ -136,7 +136,7 @@ void otaSetup(void)
}
otaPrecentageComplete = -1;
Log.error(TAG_OTA, F("%s failed (%s)"), buffer, error);
LOG_ERROR(TAG_OTA, F("%s failed (%s)"), buffer, error);
haspProgressMsg(F(D_OTA_UPDATE_FAILED));
// delay(5000);
});
@ -164,9 +164,9 @@ void otaSetup(void)
#endif
ArduinoOTA.begin();
Log.trace(TAG_OTA, F(D_SERVICE_STARTED));
LOG_INFO(TAG_OTA, F(D_SERVICE_STARTED));
} else {
Log.warning(TAG_OTA, F(D_SERVICE_DISABLED));
LOG_WARNING(TAG_OTA, F(D_SERVICE_DISABLED));
}
}
@ -201,16 +201,16 @@ void otaHttpUpdate(const char * espOtaUrl)
switch(returnCode) {
case HTTP_UPDATE_FAILED:
Log.error(TAG_FWUP, F("HTTP_UPDATE_FAILED error %i %s"), httpUpdate.getLastError(),
LOG_ERROR(TAG_FWUP, F("HTTP_UPDATE_FAILED error %i %s"), httpUpdate.getLastError(),
httpUpdate.getLastErrorString().c_str());
break;
case HTTP_UPDATE_NO_UPDATES:
Log.notice(TAG_FWUP, F("HTTP_UPDATE_NO_UPDATES"));
LOG_TRACE(TAG_FWUP, F("HTTP_UPDATE_NO_UPDATES"));
break;
case HTTP_UPDATE_OK:
Log.notice(TAG_FWUP, F("HTTP_UPDATE_OK"));
LOG_TRACE(TAG_FWUP, F("HTTP_UPDATE_OK"));
dispatch_reboot(true);
}

20
src/svc/hasp_slave.cpp
View File

@ -40,7 +40,7 @@ void slave_send_state(const __FlashStringHelper * subtopic, const char * payload
slave.ExecuteCommand((char *)cBuffer);
// Log after char buffers are cleared
Log.notice(TAG_TASM, F("TAS PUB: %sstate/%S = %s"), slaveNodeTopic, subtopic, payload);
LOG_TRACE(TAG_TASM, F("TAS PUB: %sstate/%S = %s"), slaveNodeTopic, subtopic, payload);
}
void slave_send_obj_attribute_str(uint8_t pageid, uint8_t btnid, const char * attribute, const char * data)
@ -51,13 +51,13 @@ void slave_send_obj_attribute_str(uint8_t pageid, uint8_t btnid, const char * at
pageid, btnid, attribute, data);
slave.ExecuteCommand((char *)cBuffer);
// Log after char buffers are cleared
Log.notice(TAG_TASM, F("TAS PUB: %sstate/json = {\"p[%u].b[%u].%s\":\"%s\"}"), slaveNodeTopic, pageid, btnid,
LOG_TRACE(TAG_TASM, F("TAS PUB: %sstate/json = {\"p[%u].b[%u].%s\":\"%s\"}"), slaveNodeTopic, pageid, btnid,
attribute, data);
}
void slave_send_input(uint8_t id, const char * payload)
{
// Log.verbose(TAG_TASM,F("MQTT TST: %sstate/input%u = %s"), mqttNodeTopic, id, payload); // to be removed
// LOG_VERBOSE(TAG_TASM,F("MQTT TST: %sstate/input%u = %s"), mqttNodeTopic, id, payload); // to be removed
char cBuffer[strlen(payload) + 64];
memset(cBuffer, 0, sizeof(cBuffer));
@ -65,7 +65,7 @@ void slave_send_input(uint8_t id, const char * payload)
slave.ExecuteCommand((char *)cBuffer);
// Log after char buffers are cleared
Log.notice(TAG_TASM, F("TAS PUB: %sstate/input%u = %s"), slaveNodeTopic, id, payload);
LOG_TRACE(TAG_TASM, F("TAS PUB: %sstate/input%u = %s"), slaveNodeTopic, id, payload);
}
void TASMO_TELE_JSON()
@ -92,12 +92,12 @@ void TASMO_TELE_JSON()
void TASMO_DATA_RECEIVE(char * data)
{
Log.trace(TAG_TASM, F("Slave IN [%s]"), data);
LOG_INFO(TAG_TASM, F("Slave IN [%s]"), data);
char dataType[3];
memset(dataType, 0, sizeof(dataType));
snprintf_P(dataType, sizeof(dataType), data);
Log.trace(TAG_TASM, F("dataType [%s]"), dataType);
LOG_INFO(TAG_TASM, F("dataType [%s]"), dataType);
if(!strcmp(dataType, "p[")) { //
dispatchTextLine(data);
@ -109,7 +109,7 @@ void TASMO_DATA_RECEIVE(char * data)
memset(slvVal, 0, sizeof(slvVal));
sscanf(data, "%[^=] =%s", slvCmd, slvVal);
Log.trace(TAG_TASM, F("Cmd[%s] Val[%s]"), slvCmd, slvVal);
LOG_INFO(TAG_TASM, F("Cmd[%s] Val[%s]"), slvCmd, slvVal);
if(!strcmp(slvCmd, "calData")) {
if(strlen(slvVal) != 0) {
@ -135,11 +135,11 @@ void TASMO_EVERY_SECOND(void)
if(ledstate) {
ledstate = false;
// digitalWrite(HASP_OUTPUT_PIN, 1);
// Log.trace(TAG_TASM,F("LED OFF"));
// LOG_INFO(TAG_TASM,F("LED OFF"));
} else {
ledstate = true;
// digitalWrite(HASP_OUTPUT_PIN, 0);
// Log.trace(TAG_TASM,F("LED ON"));
// LOG_INFO(TAG_TASM,F("LED ON"));
}
}
@ -150,7 +150,7 @@ void slaveSetup()
slave.attach_FUNC_JSON(TASMO_TELE_JSON);
slave.attach_FUNC_COMMAND_SEND(TASMO_DATA_RECEIVE);
Log.notice(TAG_TASM, F("HASP SLAVE LOADED"));
LOG_TRACE(TAG_TASM, F("HASP SLAVE LOADED"));
}
void slaveLoop(void)

28
src/svc/hasp_telnet.cpp
View File

@ -41,7 +41,7 @@ ConsoleInput * telnetConsole;
void telnetClientDisconnect()
{
Log.unregisterOutput(1); // telnetClient
Log.notice(TAG_TELN, F(D_TELNET_CLOSING_CONNECTION), telnetClient.remoteIP().toString().c_str());
LOG_TRACE(TAG_TELN, F(D_TELNET_CLOSING_CONNECTION), telnetClient.remoteIP().toString().c_str());
telnetLoginState = TELNET_UNAUTHENTICATED;
telnetLoginAttempt = 0; // Initial attempt
// delete telnetConsole;
@ -61,7 +61,7 @@ void telnetClientLogon()
telnetClient.flush();
// telnetClient.setTimeout(10);
Log.notice(TAG_TELN, F(D_TELNET_CLIENT_LOGIN_FROM), telnetClient.remoteIP().toString().c_str());
LOG_TRACE(TAG_TELN, F(D_TELNET_CLIENT_LOGIN_FROM), telnetClient.remoteIP().toString().c_str());
}
void telnetAcceptClient()
@ -72,10 +72,10 @@ void telnetAcceptClient()
}
telnetClient = telnetServer->available(); // ready for new client
if(!telnetClient) {
Log.verbose(TAG_TELN, F(D_TELNET_CLIENT_NOT_CONNECTED));
LOG_VERBOSE(TAG_TELN, F(D_TELNET_CLIENT_NOT_CONNECTED));
return;
}
Log.trace(TAG_TELN, F(D_TELNET_CLIENT_CONNECT_FROM), telnetClient.remoteIP().toString().c_str());
LOG_INFO(TAG_TELN, F(D_TELNET_CLIENT_CONNECT_FROM), telnetClient.remoteIP().toString().c_str());
telnetClient.setNoDelay(true);
/* Avoid a buffer here */
@ -116,7 +116,7 @@ static inline void telnetProcessLine()
telnetLoginState = TELNET_UNAUTHENTICATED;
telnetLoginAttempt++; // Subsequent attempt
telnetClient.println(F(D_TELNET_AUTHENTICATION_FAILED"\r\n"));
Log.warning(TAG_TELN, F(D_TELNET_INCORRECT_LOGIN_ATTEMPT), telnetClient.remoteIP().toString().c_str());
LOG_WARNING(TAG_TELN, F(D_TELNET_INCORRECT_LOGIN_ATTEMPT), telnetClient.remoteIP().toString().c_str());
if(telnetLoginAttempt >= 3) {
telnetClientDisconnect();
} else {
@ -202,7 +202,7 @@ static inline void telnetProcessLine(const char * input)
telnetLoginState = TELNET_UNAUTHENTICATED;
telnetLoginAttempt++; // Subsequent attempt
telnetClient.println(F(D_TELNET_AUTHENTICATION_FAILED "\r\n"));
Log.warning(TAG_TELN, F(D_TELNET_INCORRECT_LOGIN_ATTEMPT), telnetClient.remoteIP().toString().c_str());
LOG_WARNING(TAG_TELN, F(D_TELNET_INCORRECT_LOGIN_ATTEMPT), telnetClient.remoteIP().toString().c_str());
if(telnetLoginAttempt >= 3) {
telnetClientDisconnect();
} else {
@ -235,9 +235,9 @@ void telnetSetup()
// if(!telnetServer) telnetServer = new EthernetServer(telnetPort);
// if(telnetServer) {
telnetServer->begin();
Log.trace(TAG_TELN, F(D_TELNET_STARTED));
LOG_INFO(TAG_TELN, F(D_TELNET_STARTED));
// } else {
// Log.error(TAG_TELN,F("Failed to start telnet server"));
// LOG_ERROR(TAG_TELN,F("Failed to start telnet server"));
//}
#else
if(!telnetServer) telnetServer = new WiFiServer(telnetPort);
@ -248,12 +248,12 @@ void telnetSetup()
telnetConsole = new ConsoleInput(&telnetClient, HASP_CONSOLE_BUFFER);
if(telnetConsole != NULL) {
telnetConsole->setLineCallback(telnetProcessLine);
Log.trace(TAG_TELN, F(D_TELNET_STARTED));
LOG_INFO(TAG_TELN, F(D_TELNET_STARTED));
return;
}
}
Log.error(TAG_TELN, F(D_TELNET_FAILED));
LOG_ERROR(TAG_TELN, F(D_TELNET_FAILED));
#endif
}
}
@ -272,12 +272,12 @@ void telnetLoop()
// telnetAcceptClient(client);
telnetClient = client; // ready for new client
// Log.notice(TAG_TELN,F("Client connected from %s"), telnetClient.remoteIP().toString().c_str());
// LOG_TRACE(TAG_TELN,F("Client connected from %s"), telnetClient.remoteIP().toString().c_str());
if(!telnetClient) {
Log.warning(TAG_TELN, F(D_TELNET_CLIENT_NOT_CONNECTED));
LOG_WARNING(TAG_TELN, F(D_TELNET_CLIENT_NOT_CONNECTED));
return;
}
Log.notice(TAG_TELN, F(D_TELNET_CLIENT_CONNECTED));
LOG_TRACE(TAG_TELN, F(D_TELNET_CLIENT_CONNECTED));
/* Avoid a buffer here */
// telnetClient.print(0xFF); // DO TERMINAL-TYPE
@ -294,7 +294,7 @@ void telnetLoop()
if(!telnetClient.connected()) { // nobody is already connected
telnetAcceptClient(); // allow the new client
} else {
Log.warning(TAG_TELN, F(D_TELNET_CLIENT_REJECTED));
LOG_WARNING(TAG_TELN, F(D_TELNET_CLIENT_REJECTED));
telnetServer->available().stop(); // already have a client, block new connections
}
} else {