mirror of
https://github.com/HASwitchPlate/openHASP.git
synced 2025-07-22 18:56:34 +00:00
Overall log level and log macros
This commit is contained in:
parent
109991cd01
commit
3c1366ee80
65
include/hasp_macro.h
Normal file
65
include/hasp_macro.h
Normal 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
|
@ -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
|
||||
}
|
||||
|
||||
|
@ -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);
|
||||
|
||||
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
@ -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 {
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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}
|
||||
|
||||
|
@ -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
|
@ -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
|
@ -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()
|
||||
|
@ -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
|
||||
|
@ -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);
|
||||
}
|
@ -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 {
|
||||
|
@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -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
|
||||
|
@ -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;
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
@ -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);
|
||||
|
@ -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
|
@ -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
|
||||
}
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
|
@ -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)
|
||||
|
@ -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
|
||||
}
|
||||
|
||||
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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);
|
||||
}
|
||||
|
||||
|
@ -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)
|
||||
|
@ -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 {
|
||||
|
Loading…
x
Reference in New Issue
Block a user