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

Changes to haspDevice class

Browse Source
This commit is contained in:
fvanroie 2021-02-18 19:06:46 +01:00
parent b7366336cc
commit 7857ea03ed
26 changed files with 669 additions and 452 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/dev/device.h
View File

@ -8,6 +8,11 @@
#include "Arduino.h"
#endif
#ifdef WINDOWS
#include <cstdint>
#include "Windows.h"
#endif
namespace dev {
class BaseDevice {
@ -17,6 +22,19 @@ class BaseDevice {
virtual void reboot()
{}
virtual const char* get_hostname()
{
return "";
}
virtual const char* get_core_version()
{
return "";
}
virtual const char* get_display_driver()
{
return "";
}
virtual void init()
{}
virtual void post_setup()
@ -60,10 +78,13 @@ class BaseDevice {
#elif defined(STM32F4)
#warning Building for STM32F4xx Devices
#include "stm32f4/stm32f4.h"
#elif defined(WINDOWS)
#warning Building for Win32 Devices
#include "win32/hasp_win32.h"
#else
#warning Building for Generic Devices
using dev::BaseDevice;
extern dev::BaseDevice haspDevice;
#endif
#endif

30
src/dev/esp32/esp32.cpp
View File

@ -12,6 +12,7 @@
#include "hasp_conf.h"
#include "hasp_debug.h"
#include "hasp/hasp_utilities.h"
#define BACKLIGHT_CHANNEL 0
@ -22,17 +23,31 @@ void Esp32Device::reboot()
ESP.restart();
}
const char* Esp32Device::get_hostname()
{
return hostname.c_str();
}
const char* Esp32Device::get_core_version()
{
return ESP.getSdkVersion();
}
const char* Esp32Device::get_display_driver()
{
return Utilities::tft_driver_name().c_str();
}
void Esp32Device::set_backlight_pin(uint8_t pin)
{
Esp32Device::backlight_pin = pin;
/* Setup Backlight Control Pin */
if(pin >= 0) {
LOG_VERBOSE(TAG_GUI, F("Backlight : Pin %d"), pin);
/* Setup Backlight Control Pin */
if(pin != (uint8_t)-1) {
LOG_VERBOSE(TAG_GUI, F("Backlight : Pin %d"), pin);
ledcSetup(BACKLIGHT_CHANNEL, 20000, 12);
ledcAttachPin(pin, BACKLIGHT_CHANNEL);
update_backlight();
} else {
LOG_VERBOSE(TAG_GUI, F("Backlight : Pin not set"));
}
}
@ -62,11 +77,10 @@ bool Esp32Device::get_backlight_power()
void Esp32Device::update_backlight()
{
if(backlight_pin == -1) return;
if(backlight_pin == (uint8_t)-1) return;
if(backlight_power) { // The backlight is ON
ledcWrite(BACKLIGHT_CHANNEL, map(backlight_level, 0, 100, 0, 4095)); // ledChannel and value
}
uint32_t duty = backlight_power ? map(backlight_level, 0, 100, 0, 4095) : 0;
ledcWrite(BACKLIGHT_CHANNEL, duty); // ledChannel and value
}
size_t Esp32Device::get_free_max_block()

16
src/dev/esp32/esp32.h
View File

@ -15,25 +15,24 @@ class Esp32Device : public BaseDevice {
public:
void reboot() override;
const char* get_hostname();
const char* get_core_version();
const char* get_display_driver();
void set_backlight_pin(uint8_t pin) override;
void set_backlight_level(uint8_t val) override;
uint8_t get_backlight_level() override;
void set_backlight_power(bool power) override;
bool get_backlight_power() override;
size_t get_free_max_block() override;
size_t get_free_heap() override;
uint8_t get_heap_fragmentation() override;
uint16_t get_cpu_frequency() override;
private:
std::string hostname;
uint8_t backlight_pin;
uint8_t backlight_level;
uint8_t backlight_power;
@ -43,8 +42,6 @@ class Esp32Device : public BaseDevice {
} // namespace dev
using dev::Esp32Device;
#if defined(LANBONL8)
#warning Building for Lanbon L8
#include "lanbonl8.h"
@ -52,6 +49,7 @@ using dev::Esp32Device;
#warning Building for M5Stack core2
#include "m5stackcore2.h"
#else
using dev::Esp32Device;
extern dev::Esp32Device haspDevice;
#endif
#endif // ESP32

3
src/dev/esp32/lanbonl8.cpp
View File

@ -14,7 +14,7 @@
#define BACKLIGHT_CHANNEL 0
#define REF_VOLTAGE 1100
esp_adc_cal_characteristics_t * adc_chars =
esp_adc_cal_characteristics_t* adc_chars =
new esp_adc_cal_characteristics_t; // adc_chars = calloc(1, sizeof(esp_adc_cal_characteristics_t));
namespace dev {
@ -64,4 +64,5 @@ void LanbonL8::init()
} // namespace dev
dev::LanbonL8 haspDevice;
#endif

1
src/dev/esp32/lanbonl8.h
View File

@ -17,6 +17,7 @@ class LanbonL8 : public Esp32Device {
} // namespace dev
using dev::LanbonL8;
extern dev::LanbonL8 haspDevice;
#endif

1
src/dev/esp32/m5stackcore2.cpp
View File

@ -43,4 +43,5 @@ void M5StackCore2::init(void)
} // namespace dev
dev::M5StackCore2 haspDevice;
#endif

1
src/dev/esp8266/esp8266.h
View File

@ -45,7 +45,6 @@ class Esp8266Device : public BaseDevice {
} // namespace dev
using dev::Esp8266Device;
extern dev::Esp8266Device haspDevice;
#endif // ESP8266

86
src/dev/win32/hasp_win32.cpp Normal file
View File

@ -0,0 +1,86 @@
#if defined(WINDOWS)
#include <cstdint>
#include "Windows.h"
#include "hasp_win32.h"
#include "hasp_conf.h"
#include "hasp_debug.h"
namespace dev {
void Win32Device::reboot()
{}
const char* Win32Device::get_hostname()
{
return "winhasp";
}
const char* Win32Device::get_core_version()
{
return "win32";
}
const char* Win32Device::get_display_driver()
{
return "test";
}
void Win32Device::set_backlight_pin(uint8_t pin)
{
Win32Device::backlight_pin = pin;
}
void Win32Device::set_backlight_level(uint8_t level)
{
backlight_level = level >= 0 ? level : 0;
backlight_level = backlight_level <= 100 ? backlight_level : 100;
update_backlight();
}
uint8_t Win32Device::get_backlight_level()
{
return backlight_level;
}
void Win32Device::set_backlight_power(bool power)
{
backlight_power = power;
update_backlight();
}
bool Win32Device::get_backlight_power()
{
return backlight_power != 0;
}
void Win32Device::update_backlight()
{
if(backlight_pin == -1) return;
}
size_t Win32Device::get_free_max_block()
{
return 0;
}
size_t Win32Device::get_free_heap(void)
{
return 0;
}
uint8_t Win32Device::get_heap_fragmentation()
{
return 0;
}
uint16_t Win32Device::get_cpu_frequency()
{
return 0;
}
} // namespace dev
dev::Win32Device haspDevice;
#endif // WINDOWS

52
src/dev/win32/hasp_win32.h Normal file
View File

@ -0,0 +1,52 @@
/* MIT License - Copyright (c) 2020 Francis Van Roie
For full license information read the LICENSE file in the project folder */
#ifndef HASP_DEVICE_WINDOWS_H
#define HASP_DEVICE_WINDOWS_H
#include <cstdint>
#include "Windows.h"
#include "hasp_conf.h"
#include "../device.h"
#if defined(WINDOWS)
namespace dev {
class Win32Device : public BaseDevice {
public:
void reboot() override;
const char* get_hostname() override;
const char* get_core_version() override;
const char* get_display_driver() override;
void set_backlight_pin(uint8_t pin);
void set_backlight_level(uint8_t val);
uint8_t get_backlight_level();
void set_backlight_power(bool power);
bool get_backlight_power();
size_t get_free_max_block();
size_t get_free_heap();
uint8_t get_heap_fragmentation();
uint16_t get_cpu_frequency();
private:
uint8_t backlight_pin;
uint8_t backlight_level;
uint8_t backlight_power;
void update_backlight();
};
} // namespace dev
using dev::Win32Device;
extern dev::Win32Device haspDevice;
#endif // WINDOWS
#endif // HASP_DEVICE_WINDOWS_H

24
src/drv/tft_espi_drv.cpp
View File

@ -36,8 +36,8 @@
/**********************
* STATIC PROTOTYPES
**********************/
static void tftShowConfig(TFT_eSPI & tft);
static inline void tftShowLogo(TFT_eSPI & tft);
static void tftShowConfig(TFT_eSPI& tft);
static inline void tftShowLogo(TFT_eSPI& tft);
/**********************
* STATIC VARIABLES
@ -74,7 +74,7 @@ void tft_espi_init(uint8_t rotation, bool invert_display)
tftShowConfig(tft);
}
void tft_espi_flush(lv_disp_drv_t * disp, const lv_area_t * area, lv_color_t * color_p)
void tft_espi_flush(lv_disp_drv_t* disp, const lv_area_t* area, lv_color_t* color_p)
{
size_t len = lv_area_get_size(area);
@ -82,9 +82,9 @@ void tft_espi_flush(lv_disp_drv_t * disp, const lv_area_t * area, lv_color_t * c
tft.startWrite(); /* Start new TFT transaction */
tft.setWindow(area->x1, area->y1, area->x2, area->y2); /* set the working window */
#ifdef USE_DMA_TO_TFT
tft.pushPixelsDMA((uint16_t *)color_p, len); /* Write words at once */
tft.pushPixelsDMA((uint16_t*)color_p, len); /* Write words at once */
#else
tft.pushPixels((uint16_t *)color_p, len); /* Write words at once */
tft.pushPixels((uint16_t*)color_p, len); /* Write words at once */
#endif
tft.endWrite(); /* terminate TFT transaction */
@ -104,7 +104,7 @@ void tft_espi_flush(lv_disp_drv_t * disp, const lv_area_t * area, lv_color_t * c
#if defined(TOUCH_CS)
void tft_espi_calibrate(uint16_t * calData)
void tft_espi_calibrate(uint16_t* calData)
{
tft.fillScreen(TFT_BLACK);
tft.setCursor(20, 0);
@ -120,14 +120,14 @@ void tft_espi_calibrate(uint16_t * calData)
tft.setTouch(calData);
}
void tft_espi_set_touch(uint16_t * calData)
void tft_espi_set_touch(uint16_t* calData)
{
tft.setTouch(calData);
}
bool tft_espi_get_touch(int16_t * touchX, int16_t * touchY, uint16_t threshold)
bool tft_espi_get_touch(int16_t* touchX, int16_t* touchY, uint16_t threshold)
{
return tft.getTouch((uint16_t *)touchX, (uint16_t *)touchY, threshold);
return tft.getTouch((uint16_t*)touchX, (uint16_t*)touchY, threshold);
}
#endif
@ -149,7 +149,7 @@ static void tftOffsetInfo(uint8_t pin, uint8_t x_offset, uint8_t y_offset)
}
}
static void tftPinInfo(const __FlashStringHelper * pinfunction, int8_t pin)
static void tftPinInfo(const __FlashStringHelper* pinfunction, int8_t pin)
{
if(pin != -1) {
char buffer[64];
@ -158,7 +158,7 @@ static void tftPinInfo(const __FlashStringHelper * pinfunction, int8_t pin)
}
}
static void tftShowConfig(TFT_eSPI & tft)
static void tftShowConfig(TFT_eSPI& tft)
{
setup_t tftSetup;
tft.getSetup(tftSetup);
@ -246,7 +246,7 @@ static void tftShowConfig(TFT_eSPI & tft)
}
}
static inline void tftShowLogo(TFT_eSPI & tft)
static inline void tftShowLogo(TFT_eSPI& tft)
{
tft.fillScreen(TFT_DARKCYAN);
int x = (tft.width() - logoWidth) / 2;

63
src/hasp/hasp.cpp
View File

@ -8,13 +8,14 @@
#include "ArduinoJson.h"
#include "hasp_conf.h"
#include "dev/device.h"
#if HASP_USE_EEPROM > 0
#include "StreamUtils.h" // For EEPromStream
#endif
#include "lvgl.h"
#include "lv_conf.h"
#include "hasp_conf.h"
#if HASP_USE_DEBUG > 0
#include "../hasp_debug.h"
@ -32,7 +33,6 @@
#include "hasp_attribute.h"
#include "hasp.h"
#include "dev/device.h"
#include "lv_theme_hasp.h"
#if HASP_USE_EEPROM > 0
@ -73,7 +73,7 @@ LV_IMG_DECLARE(img_bubble_pattern)
/**********************
* GLOBAL FUNCTIONS
**********************/
void haspLoadPage(const char * pages);
void haspLoadPage(const char* pages);
////////////////////////////////////////////////////////////////////////////////////////////////////
uint8_t hasp_sleep_state = HASP_SLEEP_OFF; // Used in hasp_drv_touch.cpp
@ -88,18 +88,18 @@ char haspPagesPath[32] = "/pages.jsonl";
char haspZiFontPath[32];
lv_style_t style_mbox_bg; /*Black bg. style with opacity*/
lv_obj_t * kb;
lv_obj_t* kb;
// lv_font_t * defaultFont;
lv_obj_t * pages[HASP_NUM_PAGES];
static lv_font_t * haspFonts[4] = {nullptr, LV_THEME_DEFAULT_FONT_NORMAL, LV_THEME_DEFAULT_FONT_SUBTITLE,
LV_THEME_DEFAULT_FONT_TITLE};
uint8_t current_page = 1;
lv_obj_t* pages[HASP_NUM_PAGES];
static lv_font_t* haspFonts[4] = {nullptr, LV_THEME_DEFAULT_FONT_NORMAL, LV_THEME_DEFAULT_FONT_SUBTITLE,
LV_THEME_DEFAULT_FONT_TITLE};
uint8_t current_page = 1;
/**
* Get Font ID
*/
lv_font_t * hasp_get_font(uint8_t fontid)
lv_font_t* hasp_get_font(uint8_t fontid)
{
if(fontid >= 4) {
return nullptr;
@ -145,7 +145,7 @@ void hasp_enable_wakeup_touch()
/**
* Return the sleep times
*/
void hasp_get_sleep_time(uint16_t & short_time, uint16_t & long_time)
void hasp_get_sleep_time(uint16_t& short_time, uint16_t& long_time)
{
short_time = sleepTimeShort;
long_time = sleepTimeLong;
@ -163,16 +163,17 @@ void hasp_set_sleep_time(uint16_t short_time, uint16_t long_time)
/**
* Checks if we went to sleep, wake up is handled in the event handlers
*/
// void haspEverySecond()
// {
// hasp_update_sleep_state();
// }
void haspEverySecond()
{
hasp_update_sleep_state();
dispatchEverySecond();
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Get Page Object by PageID
*/
lv_obj_t * get_page_obj(uint8_t pageid)
lv_obj_t* get_page_obj(uint8_t pageid)
{
if(pageid == 0) return lv_layer_top(); // 254
if(pageid == 255) return lv_layer_sys();
@ -180,9 +181,9 @@ lv_obj_t * get_page_obj(uint8_t pageid)
return pages[pageid - PAGE_START_INDEX];
}
bool get_page_id(lv_obj_t * obj, uint8_t * pageid)
bool get_page_id(lv_obj_t* obj, uint8_t* pageid)
{
lv_obj_t * page = lv_obj_get_screen(obj);
lv_obj_t* page = lv_obj_get_screen(obj);
if(!page) return false;
@ -248,8 +249,8 @@ void haspReconnect()
// Shows/hides the the global progress bar and updates the value
void haspProgressVal(uint8_t val)
{
lv_obj_t * layer = lv_disp_get_layer_sys(NULL);
lv_obj_t * bar = hasp_find_obj_from_parent_id(get_page_obj(255), (uint8_t)10);
lv_obj_t* layer = lv_disp_get_layer_sys(NULL);
lv_obj_t* bar = hasp_find_obj_from_parent_id(get_page_obj(255), (uint8_t)10);
if(layer && bar) {
if(val == 255) {
if(!lv_obj_get_hidden(bar)) {
@ -276,9 +277,9 @@ void haspProgressVal(uint8_t val)
}
// Sets the value string of the global progress bar
void haspProgressMsg(const char * msg)
void haspProgressMsg(const char* msg)
{
lv_obj_t * bar = hasp_find_obj_from_parent_id(get_page_obj(255), (uint8_t)10);
lv_obj_t* bar = hasp_find_obj_from_parent_id(get_page_obj(255), (uint8_t)10);
if(bar) {
char value_str[10];
@ -299,16 +300,16 @@ void haspProgressMsg(const char * msg)
#ifdef ARDUINO
// Sets the value string of the global progress bar
void haspProgressMsg(const __FlashStringHelper * msg)
void haspProgressMsg(const __FlashStringHelper* msg)
{
haspProgressMsg(String(msg).c_str());
}
#endif
/*Add a custom apply callback*/
static void custom_font_apply_cb(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
static void custom_font_apply_cb(lv_theme_t* th, lv_obj_t* obj, lv_theme_style_t name)
{
lv_style_list_t * list;
lv_style_list_t* list;
switch(name) {
case LV_THEME_BTN:
@ -377,7 +378,7 @@ void haspSetup(void)
if(haspThemeId == 9) haspThemeId = 5; // update old material id
if(haspThemeId < 0 || haspThemeId > 5) haspThemeId = 1; // check bounds
lv_theme_t * th = NULL;
lv_theme_t* th = NULL;
#if(LV_USE_THEME_HASP == 1)
lv_theme_hasp_flag_t hasp_flags = LV_THEME_HASP_FLAG_LIGHT;
#endif
@ -530,14 +531,14 @@ void hasp_background(uint16_t pageid, uint16_t imageid)
///////////////////////////////////////////////////////////////////////////////////////////////////////////
void haspGetVersion(char * version, size_t len)
void haspGetVersion(char* version, size_t len)
{
snprintf_P(version, len, PSTR("%u.%u.%u"), HASP_VER_MAJ, HASP_VER_MIN, HASP_VER_REV);
}
void haspClearPage(uint16_t pageid)
{
lv_obj_t * page = get_page_obj(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);
} else if(page == lv_layer_sys() /*|| page == lv_layer_top()*/) {
@ -555,7 +556,7 @@ uint8_t haspGetPage()
void haspSetPage(uint8_t pageid)
{
lv_obj_t * page = get_page_obj(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);
} else {
@ -566,7 +567,7 @@ void haspSetPage(uint8_t pageid)
}
}
void haspLoadPage(const char * pagesfile)
void haspLoadPage(const char* pagesfile)
{
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
if(pagesfile[0] == '\0') return;
@ -602,7 +603,7 @@ void haspLoadPage(const char * pagesfile)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#if HASP_USE_CONFIG > 0
bool haspGetConfig(const JsonObject & settings)
bool haspGetConfig(const JsonObject& settings)
{
bool changed = false;
@ -636,7 +637,7 @@ bool haspGetConfig(const JsonObject & settings)
*
* @param[in] settings JsonObject with the config settings.
**/
bool haspSetConfig(const JsonObject & settings)
bool haspSetConfig(const JsonObject& settings)
{
configOutput(settings, TAG_HASP);
bool changed = false;

46
src/hasp/hasp.h
View File

@ -15,7 +15,8 @@
#include "hasp_utilities.h"
#if HASP_USE_DEBUG > 0
#include "../hasp_debug.h"
#include "../hasp_debug.h"
#include "dev/device.h"
#endif
#define NORMALIZE(a, b, c) map(a, b, c, 0, 0xFFFFU)
@ -30,12 +31,12 @@ extern "C" {
#if HASP_USE_APP > 0
/*********************
* DEFINES
*********************/
#define HASP_SLEEP_OFF 0
#define HASP_SLEEP_SHORT 1
#define HASP_SLEEP_LONG 2
/*********************
* DEFINES
*********************/
#define HASP_SLEEP_OFF 0
#define HASP_SLEEP_SHORT 1
#define HASP_SLEEP_LONG 2
/**********************
* TYPEDEFS
@ -50,41 +51,40 @@ extern "C" {
*/
void haspSetup(void);
void haspLoop(void);
// void haspEverySecond(void); // See MACROS
void haspEverySecond(void);
void haspReconnect(void);
void haspDisconnect(void);
lv_obj_t * get_page_obj(uint8_t pageid);
bool get_page_id(lv_obj_t * obj, uint8_t * pageid);
lv_obj_t* get_page_obj(uint8_t pageid);
bool get_page_id(lv_obj_t* obj, uint8_t* pageid);
void haspSetPage(uint8_t id);
uint8_t haspGetPage();
void haspClearPage(uint16_t pageid);
void haspGetVersion(char * version, size_t len);
void haspGetVersion(char* version, size_t len);
// void haspBackground(uint16_t pageid, uint16_t imageid);
// void haspNewObject(const JsonObject & config, uint8_t & saved_page_id);
void haspProgressVal(uint8_t val);
#if HASP_USE_CONFIG > 0
bool haspGetConfig(const JsonObject & settings);
bool haspSetConfig(const JsonObject & settings);
#endif
#if HASP_USE_CONFIG > 0
bool haspGetConfig(const JsonObject& settings);
bool haspSetConfig(const JsonObject& settings);
#endif
lv_font_t * hasp_get_font(uint8_t fontid);
lv_font_t* hasp_get_font(uint8_t fontid);
bool hasp_update_sleep_state();
void hasp_get_sleep_time(uint16_t & short_time, uint16_t & long_time);
void hasp_get_sleep_time(uint16_t& short_time, uint16_t& long_time);
void hasp_set_sleep_time(uint16_t short_time, uint16_t long_time);
void hasp_enable_wakeup_touch();
/**********************
* MACROS
**********************/
#define haspEverySecond hasp_update_sleep_state
/**********************
* MACROS
**********************/
#endif /*HASP_USE_APP*/
@ -92,9 +92,9 @@ void hasp_enable_wakeup_touch();
} /* extern "C" */
#endif
void haspProgressMsg(const char * msg);
void haspProgressMsg(const char* msg);
#ifdef ARDUINO
void haspProgressMsg(const __FlashStringHelper * msg);
void haspProgressMsg(const __FlashStringHelper* msg);
#endif
#endif /*HASP_H*/

27
src/hasp/hasp_dispatch.cpp
View File

@ -46,7 +46,7 @@
extern uint8_t hasp_sleep_state;
dispatch_conf_t dispatch_setings = {.teleperiod = 300};
dispatch_conf_t dispatch_setings = {.teleperiod = 10};
uint32_t dispatchLastMillis;
uint8_t nCommands = 0;
@ -897,18 +897,32 @@ void dispatch_output_statusupdate(const char*, const char*)
{
char buffer[128];
printf("%s %d\n", __FILE__, __LINE__);
fflush(stdout);
haspGetVersion(buffer, sizeof(buffer));
snprintf_P(data, sizeof(data),
PSTR("{\"node\":\"%s\",\"status\":\"available\",\"version\":\"%s\",\"uptime\":%lu,"),
mqttGetNodename().c_str(), buffer, long(millis() / 1000));
haspDevice.get_hostname(), buffer, long(millis() / 1000));
printf("%s %d\n", __FILE__, __LINE__);
fflush(stdout);
#if HASP_USE_WIFI > 0
network_get_statusupdate(buffer, sizeof(buffer));
strcat(data, buffer);
#endif
printf("%s %d\n", __FILE__, __LINE__);
fflush(stdout);
snprintf_P(buffer, sizeof(buffer), PSTR("\"heapFree\":%u,\"heapFrag\":%u,\"espCore\":\"%s\","),
haspDevice.get_free_heap(), haspDevice.get_heap_fragmentation(), halGetCoreVersion().c_str());
haspDevice.get_free_heap(), haspDevice.get_heap_fragmentation(), haspDevice.get_core_version());
strcat(data, buffer);
printf("%s %d\n", __FILE__, __LINE__);
fflush(stdout);
snprintf_P(buffer, sizeof(buffer), PSTR("\"espCanUpdate\":\"false\",\"page\":%u,\"numPages\":%u,"),
haspGetPage(), (HASP_NUM_PAGES));
strcat(data, buffer);
@ -918,8 +932,11 @@ void dispatch_output_statusupdate(const char*, const char*)
strcat(data, buffer);
#endif
printf("%s %d\n", __FILE__, __LINE__);
fflush(stdout);
snprintf_P(buffer, sizeof(buffer), PSTR("\"tftDriver\":\"%s\",\"tftWidth\":%u,\"tftHeight\":%u}"),
halDisplayDriverName().c_str(), (TFT_WIDTH), (TFT_HEIGHT));
haspDevice.get_display_driver(), (TFT_WIDTH), (TFT_HEIGHT));
strcat(data, buffer);
}
mqtt_send_state(F("statusupdate"), data);
@ -1006,7 +1023,7 @@ void dispatchLoop()
}
#if 1 || ARDUINO
void everySecond()
void dispatchEverySecond()
{
if(dispatch_setings.teleperiod > 0 && (millis() - dispatchLastMillis) >= dispatch_setings.teleperiod * 1000) {
dispatchLastMillis = millis();

41
src/hasp/hasp_dispatch.h
View File

@ -7,7 +7,8 @@
#include "ArduinoJson.h"
#include "lvgl.h"
struct dispatch_conf_t {
struct dispatch_conf_t
{
uint16_t teleperiod;
};
@ -32,43 +33,43 @@ void dispatchStart(void);
void dispatchStop(void);
/* ===== Special Event Processors ===== */
void dispatch_topic_payload(const char * topic, const char * payload);
void dispatch_text_line(const char * cmnd);
void dispatch_topic_payload(const char* topic, const char* payload);
void dispatch_text_line(const char* cmnd);
#ifdef ARDUINO
void dispatch_parse_jsonl(Stream &stream);
void dispatch_parse_jsonl(Stream& stream);
#else
void dispatch_parse_jsonl(std::istringstream &stream);
void dispatch_parse_jsonl(std::istringstream& stream);
#endif
void dispatch_clear_page(const char * page);
void dispatch_json_error(uint8_t tag, DeserializationError & jsonError);
void dispatch_clear_page(const char* page);
void dispatch_json_error(uint8_t tag, DeserializationError& jsonError);
// void dispatchPage(uint8_t page);
void dispatch_page_next();
void dispatch_page_prev();
void dispatch_dim(const char * level);
void dispatch_backlight(const char * payload);
void dispatch_dim(const char* level);
void dispatch_backlight(const char* payload);
void dispatch_web_update(const char * espOtaUrl);
void dispatch_web_update(const char* espOtaUrl);
void dispatch_reboot(bool saveConfig);
void dispatch_output_idle_state(uint8_t state);
void dispatch_output_statusupdate(const char *, const char *);
void dispatch_output_statusupdate(const char*, const char*);
void dispatch_current_state();
void dispatch_gpio_input_event(uint8_t pin, uint8_t group, uint8_t eventid);
void dispatch_object_event(lv_obj_t * obj, uint8_t eventid);
void dispatch_object_event(lv_obj_t* obj, uint8_t eventid);
bool dispatch_get_event_state(uint8_t eventid);
void dispatch_get_event_name(uint8_t eventid, char * buffer, size_t size);
void dispatch_object_value_changed(lv_obj_t * obj, int16_t state);
void dispatch_get_event_name(uint8_t eventid, char* buffer, size_t size);
void dispatch_object_value_changed(lv_obj_t* obj, int16_t state);
void dispatch_normalized_group_value(uint8_t groupid, uint16_t value, lv_obj_t * obj);
void dispatch_normalized_group_value(uint8_t groupid, uint16_t value, lv_obj_t* obj);
void dispatch_send_obj_attribute_str(uint8_t pageid, uint8_t btnid, const char * attribute, const char * data);
void dispatch_send_obj_attribute_int(uint8_t pageid, uint8_t btnid, const char * attribute, int32_t val);
void dispatch_send_obj_attribute_color(uint8_t pageid, uint8_t btnid, const char * attribute, uint8_t r, uint8_t g,
void dispatch_send_obj_attribute_str(uint8_t pageid, uint8_t btnid, const char* attribute, const char* data);
void dispatch_send_obj_attribute_int(uint8_t pageid, uint8_t btnid, const char* attribute, int32_t val);
void dispatch_send_obj_attribute_color(uint8_t pageid, uint8_t btnid, const char* attribute, uint8_t r, uint8_t g,
uint8_t b);
/* ===== Getter and Setter Functions ===== */
@ -78,8 +79,8 @@ void dispatch_send_obj_attribute_color(uint8_t pageid, uint8_t btnid, const char
/* ===== Structs and Constants ===== */
struct haspCommand_t
{
void (*func)(const char *, const char *);
const char * p_cmdstr;
void (*func)(const char*, const char*);
const char* p_cmdstr;
};
#endif

102
src/hasp/hasp_object.cpp
View File

@ -14,12 +14,12 @@
******************************************************************************************** */
#ifdef ARDUINO
#include "ArduinoLog.h"
#include "ArduinoLog.h"
#endif
#include "lvgl.h"
#if LVGL_VERSION_MAJOR != 7
#include "../lv_components.h"
#include "../lv_components.h"
#endif
#include "hasp.h"
@ -29,31 +29,31 @@
#include "hasp_utilities.h"
#include "hasp_parser.h"
const char ** btnmatrix_default_map; // memory pointer to lvgl default btnmatrix map
const char** btnmatrix_default_map; // memory pointer to lvgl default btnmatrix map
// static unsigned long last_change_event = 0;
static bool last_press_was_short = false; // Avoid SHORT + UP double events
// ##################### Object Finders ########################################################
lv_obj_t * hasp_find_obj_from_parent_id(lv_obj_t * parent, uint8_t objid)
lv_obj_t* hasp_find_obj_from_parent_id(lv_obj_t* parent, uint8_t objid)
{
if(objid == 0 || parent == nullptr) return parent;
lv_obj_t * child;
lv_obj_t* child;
child = lv_obj_get_child(parent, NULL);
while(child) {
/* child found, return it */
if(objid == child->user_data.id) return child;
/* check grandchildren */
lv_obj_t * grandchild = hasp_find_obj_from_parent_id(child, objid);
lv_obj_t* grandchild = hasp_find_obj_from_parent_id(child, objid);
if(grandchild) return grandchild; /* grandchild found, return it */
/* check tabs */
if(check_obj_type(child, LV_HASP_TABVIEW)) {
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);
lv_obj_t* tab = lv_tabview_get_tab(child, 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 */
@ -74,7 +74,7 @@ lv_obj_t * hasp_find_obj_from_parent_id(lv_obj_t * parent, uint8_t objid)
// return hasp_find_obj_from_parent_id(get_page_obj(pageid), objid);
// }
bool hasp_find_id_from_obj(lv_obj_t * obj, uint8_t * pageid, uint8_t * objid)
bool hasp_find_id_from_obj(lv_obj_t* obj, uint8_t* pageid, uint8_t* objid)
{
if(!get_page_id(obj, pageid)) return false;
if(!(obj->user_data.id > 0)) return false;
@ -164,29 +164,29 @@ bool hasp_find_id_from_obj(lv_obj_t * obj, uint8_t * pageid, uint8_t * objid)
* @return true or false wether the types match
* @note
*/
bool check_obj_type(lv_obj_t * obj, lv_hasp_obj_type_t haspobjtype)
bool check_obj_type(lv_obj_t* obj, lv_hasp_obj_type_t haspobjtype)
{
#if 1
return obj->user_data.objid == (uint8_t)haspobjtype;
#else
lv_obj_type_t list;
lv_obj_get_type(obj, &list);
const char * objtype = list.type[0];
const char* objtype = list.type[0];
return check_obj_type(objtype, haspobjtype);
#endif
}
void hasp_object_tree(lv_obj_t * parent, uint8_t pageid, uint16_t level)
void hasp_object_tree(lv_obj_t* parent, uint8_t pageid, uint16_t level)
{
if(parent == nullptr) return;
/* Output parent info */
lv_obj_type_t list;
lv_obj_get_type(parent, &list);
const char * objtype = list.type[0];
const char* objtype = list.type[0];
LOG_VERBOSE(TAG_HASP, F("[%d] " HASP_OBJECT_NOTATION " %s"), level, pageid, parent->user_data.id, objtype);
lv_obj_t * child;
lv_obj_t* child;
child = lv_obj_get_child(parent, NULL);
while(child) {
/* child found, process it */
@ -201,7 +201,7 @@ void hasp_object_tree(lv_obj_t * parent, uint8_t pageid, uint16_t level)
#if 1
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);
lv_obj_t* tab = lv_tabview_get_tab(parent, i);
LOG_VERBOSE(TAG_HASP, "Found tab %i", i);
if(tab->user_data.objid) hasp_object_tree(tab, pageid, level + 1);
}
@ -211,7 +211,7 @@ void hasp_object_tree(lv_obj_t * parent, uint8_t pageid, uint16_t level)
// ##################### Value Dispatchers ########################################################
void hasp_send_obj_attribute_str(lv_obj_t * obj, const char * attribute, const char * data)
void hasp_send_obj_attribute_str(lv_obj_t* obj, const char* attribute, const char* data)
{
uint8_t pageid;
uint8_t objid;
@ -221,7 +221,7 @@ void hasp_send_obj_attribute_str(lv_obj_t * obj, const char * attribute, const c
}
}
void hasp_send_obj_attribute_int(lv_obj_t * obj, const char * attribute, int32_t val)
void hasp_send_obj_attribute_int(lv_obj_t* obj, const char* attribute, int32_t val)
{
uint8_t pageid;
uint8_t objid;
@ -231,7 +231,7 @@ void hasp_send_obj_attribute_int(lv_obj_t * obj, const char * attribute, int32_t
}
}
void hasp_send_obj_attribute_color(lv_obj_t * obj, const char * attribute, lv_color_t color)
void hasp_send_obj_attribute_color(lv_obj_t* obj, const char* attribute, lv_color_t color)
{
uint8_t pageid;
uint8_t objid;
@ -279,7 +279,7 @@ void hasp_send_obj_attribute_color(lv_obj_t * obj, const char * attribute, lv_co
* @param obj pointer to a button object
* @param event type of event that occured
*/
void generic_event_handler(lv_obj_t * obj, lv_event_t event)
void generic_event_handler(lv_obj_t* obj, lv_event_t event)
{
uint8_t eventid;
@ -348,7 +348,7 @@ void generic_event_handler(lv_obj_t * obj, lv_event_t event)
* @param obj pointer to a button matrix
* @param event type of event that occured
*/
void wakeup_event_handler(lv_obj_t * obj, lv_event_t event)
void wakeup_event_handler(lv_obj_t* obj, lv_event_t event)
{
if(obj == lv_disp_get_layer_sys(NULL)) {
hasp_update_sleep_state(); // wakeup?
@ -365,7 +365,7 @@ void wakeup_event_handler(lv_obj_t * obj, lv_event_t event)
* @param obj pointer to a switch object
* @param event type of event that occured
*/
void toggle_event_handler(lv_obj_t * obj, lv_event_t event)
void toggle_event_handler(lv_obj_t* obj, lv_event_t event)
{
if(event == LV_EVENT_VALUE_CHANGED) {
char property[4];
@ -405,7 +405,7 @@ void toggle_event_handler(lv_obj_t * obj, lv_event_t event)
* @param obj pointer to a dropdown list or roller
* @param event type of event that occured
*/
static void selector_event_handler(lv_obj_t * obj, lv_event_t event)
static void selector_event_handler(lv_obj_t* obj, lv_event_t event)
{
if(event == LV_EVENT_VALUE_CHANGED) {
char buffer[128];
@ -428,8 +428,8 @@ static void selector_event_handler(lv_obj_t * obj, lv_event_t event)
break;
case LV_HASP_BTNMATRIX: {
val = lv_btnmatrix_get_active_btn(obj);
const char * txt = lv_btnmatrix_get_btn_text(obj, val);
val = lv_btnmatrix_get_active_btn(obj);
const char* txt = lv_btnmatrix_get_btn_text(obj, val);
strncpy(buffer, txt, sizeof(buffer));
break;
}
@ -439,7 +439,7 @@ static void selector_event_handler(lv_obj_t * obj, lv_event_t event)
uint16_t col;
if(lv_table_get_pressed_cell(obj, &row, &col) != LV_RES_OK) return; // outside any cell
const char * txt = lv_table_get_cell_value(obj, row, col);
const char* txt = lv_table_get_cell_value(obj, row, col);
strncpy(buffer, txt, sizeof(buffer));
snprintf_P(property, sizeof(property), PSTR("row\":%d,\"col\":%d,\"txt"), row, col);
@ -467,7 +467,7 @@ static void selector_event_handler(lv_obj_t * obj, lv_event_t event)
* @param obj pointer to a slider
* @param event type of event that occured
*/
void slider_event_handler(lv_obj_t * obj, lv_event_t event)
void slider_event_handler(lv_obj_t* obj, lv_event_t event)
{
if(event == LV_EVENT_VALUE_CHANGED) {
/* bool is_dragged;
@ -512,7 +512,7 @@ void slider_event_handler(lv_obj_t * obj, lv_event_t event)
* @param obj pointer to a color picker
* @param event type of event that occured
*/
static void cpicker_event_handler(lv_obj_t * obj, lv_event_t event)
static void cpicker_event_handler(lv_obj_t* obj, lv_event_t event)
{
char color[6];
snprintf_P(color, sizeof(color), PSTR("color"));
@ -529,7 +529,7 @@ static void cpicker_event_handler(lv_obj_t * obj, lv_event_t event)
// ##################### State Changers ########################################################
// TODO make this a recursive function that goes over all objects only ONCE
void object_set_group_state(uint8_t groupid, uint8_t eventid, lv_obj_t * src_obj)
void object_set_group_state(uint8_t groupid, uint8_t eventid, lv_obj_t* src_obj)
{
if(groupid == 0) return;
bool state = dispatch_get_event_state(eventid);
@ -537,7 +537,7 @@ void object_set_group_state(uint8_t groupid, uint8_t eventid, lv_obj_t * src_obj
for(uint8_t page = 0; page < HASP_NUM_PAGES; page++) {
uint8_t startid = 1;
for(uint8_t objid = startid; objid < 20; objid++) {
lv_obj_t * obj = hasp_find_obj_from_parent_id(get_page_obj(page), objid);
lv_obj_t* obj = hasp_find_obj_from_parent_id(get_page_obj(page), objid);
if(obj && obj != src_obj && obj->user_data.groupid == groupid) { // skip source object, if set
lv_obj_set_state(obj, state ? LV_STATE_PRESSED | LV_STATE_CHECKED : LV_STATE_DEFAULT);
}
@ -545,11 +545,11 @@ void object_set_group_state(uint8_t groupid, uint8_t eventid, lv_obj_t * src_obj
}
}
void object_set_group_value(lv_obj_t * parent, uint8_t groupid, const char * payload)
void object_set_group_value(lv_obj_t* parent, uint8_t groupid, const char* payload)
{
if(groupid == 0 || parent == nullptr) return;
lv_obj_t * child;
lv_obj_t* child;
child = lv_obj_get_child(parent, NULL);
while(child) {
/* child found, update it */
@ -563,7 +563,7 @@ void object_set_group_value(lv_obj_t * parent, uint8_t groupid, const char * pay
//#if LVGL_VERSION_MAJOR == 7
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);
lv_obj_t* tab = lv_tabview_get_tab(child, 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 */
@ -588,9 +588,9 @@ void object_set_group_value(uint8_t groupid, int16_t state)
////////////////////////////////////////////////////////////////////////////////////////////////////
// Used in the dispatcher & hasp_new_object
void hasp_process_attribute(uint8_t pageid, uint8_t objid, const char * attr, const char * payload)
void hasp_process_attribute(uint8_t pageid, uint8_t objid, const char* attr, const char* payload)
{
if(lv_obj_t * obj = hasp_find_obj_from_parent_id(get_page_obj(pageid), objid)) {
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);
@ -599,7 +599,7 @@ void hasp_process_attribute(uint8_t pageid, uint8_t objid, const char * attr, co
// ##################### Object Creator ########################################################
int hasp_parse_json_attributes(lv_obj_t * obj, const JsonObject & doc)
int hasp_parse_json_attributes(lv_obj_t* obj, const JsonObject& doc)
{
int i = 0;
#ifdef WINDOWS
@ -608,17 +608,17 @@ int hasp_parse_json_attributes(lv_obj_t * obj, const JsonObject & doc)
std::string v;
for(JsonPair keyValue : doc) {
LOG_VERBOSE(TAG_HASP, F(" * %s => %s"), keyValue.key().c_str(), keyValue.value().as<std::string>().c_str());
LOG_VERBOSE(TAG_HASP, F(D_BULLET "%s=%s"), keyValue.key().c_str(), keyValue.value().as<std::string>().c_str());
v = keyValue.value().as<std::string>();
hasp_process_obj_attribute(obj, keyValue.key().c_str(), keyValue.value().as<std::string>().c_str(), true);
i++;
}
#else
String v((char *)0);
String v((char*)0);
v.reserve(64);
for(JsonPair keyValue : doc) {
LOG_VERBOSE(TAG_HASP, F(" * %s => %s"), keyValue.key().c_str(), keyValue.value().as<String>().c_str());
LOG_DEBUG(TAG_HASP, F(D_BULLET "%s=%s"), keyValue.key().c_str(), keyValue.value().as<String>().c_str());
v = keyValue.value().as<String>();
hasp_process_obj_attribute(obj, keyValue.key().c_str(), keyValue.value().as<String>().c_str(), true);
i++;
@ -634,11 +634,11 @@ int hasp_parse_json_attributes(lv_obj_t * obj, const JsonObject & doc)
* @param saved_page_id the pageid to use when no pageid is specified in the Json, updated when it is specified so
* following objects in the file can share the pageid
*/
void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
void hasp_new_object(const JsonObject& config, uint8_t& saved_page_id)
{
/* Page selection: page is the default parent_obj */
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);
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) {
LOG_WARNING(TAG_HASP, F(D_OBJECT_PAGE_UNKNOWN), pageid);
return;
@ -663,7 +663,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
uint8_t groupid = config[FPSTR(FP_GROUPID)].as<uint8_t>();
/* Define Objects*/
lv_obj_t * obj = hasp_find_obj_from_parent_id(parent_obj, id);
lv_obj_t* obj = hasp_find_obj_from_parent_id(parent_obj, id);
if(!obj) {
/* Create the object first */
@ -673,7 +673,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
if(config[FPSTR(FP_OBJ)].isNull()) {
return; // comments
} else {
sdbm = Utilities::get_sdbm(config[FPSTR(FP_OBJ)].as<const char *>());
sdbm = Utilities::get_sdbm(config[FPSTR(FP_OBJ)].as<const char*>());
}
} else {
sdbm = config[FPSTR(FP_OBJID)].as<uint8_t>();
@ -688,9 +688,9 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
lv_btnmatrix_set_recolor(obj, true);
lv_obj_set_event_cb(obj, selector_event_handler);
lv_btnmatrix_ext_t * ext = (lv_btnmatrix_ext_t *)lv_obj_get_ext_attr(obj);
btnmatrix_default_map = ext->map_p; // store the static pointer to the default lvgl btnmap
obj->user_data.objid = LV_HASP_BTNMATRIX;
lv_btnmatrix_ext_t* ext = (lv_btnmatrix_ext_t*)lv_obj_get_ext_attr(obj);
btnmatrix_default_map = ext->map_p; // store the static pointer to the default lvgl btnmap
obj->user_data.objid = LV_HASP_BTNMATRIX;
}
break;
@ -707,7 +707,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
case HASP_OBJ_BTN:
obj = lv_btn_create(parent_obj, NULL);
if(obj) {
lv_obj_t * lbl = lv_label_create(obj, NULL);
lv_obj_t* lbl = lv_label_create(obj, NULL);
if(lbl) {
lv_label_set_text(lbl, "");
lv_label_set_recolor(lbl, true);
@ -814,7 +814,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
obj = lv_tabview_create(parent_obj, LV_DIR_TOP, 100);
// No event handler for tabs
if(obj) {
lv_obj_t * tab;
lv_obj_t* tab;
tab = lv_tabview_add_tab(obj, "tab 1");
// lv_obj_set_user_data(tab, id + 1);
tab = lv_tabview_add_tab(obj, "tab 2");
@ -849,7 +849,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
obj = lv_tabview_create(parent_obj, NULL);
// No event handler for tabs
if(obj) {
lv_obj_t * tab;
lv_obj_t* tab;
tab = lv_tabview_add_tab(obj, "tab 1");
// lv_obj_set_user_data(tab, id + 1);
tab = lv_tabview_add_tab(obj, "tab 2");
@ -934,7 +934,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
lv_chart_add_series(obj, LV_COLOR_GREEN);
lv_chart_add_series(obj, LV_COLOR_BLUE);
lv_chart_series_t * ser = my_chart_get_series(obj, 2);
lv_chart_series_t* ser = my_chart_get_series(obj, 2);
lv_chart_set_next(obj, ser, 10);
lv_chart_set_next(obj, ser, 20);
lv_chart_set_next(obj, ser, 30);
@ -1012,7 +1012,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
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);
lv_obj_t* test = hasp_find_obj_from_parent_id(get_page_obj(pageid), (uint8_t)temp);
if(test != obj) {
LOG_ERROR(TAG_HASP, F(D_OBJECT_MISMATCH));
return;
@ -1029,7 +1029,7 @@ void hasp_new_object(const JsonObject & config, uint8_t & saved_page_id)
hasp_parse_json_attributes(obj, config);
}
void hasp_object_delete(lv_obj_t * obj)
void hasp_object_delete(lv_obj_t* obj)
{
switch(obj->user_data.objid) {
case LV_HASP_LINE:

51
src/hasp/hasp_utilities.cpp
View File

@ -1,7 +1,8 @@
#include <cctype>
#include <string>
#ifdef ARDUINO
#include "Arduino.h"
#include "Arduino.h"
#endif
#include "hasp_conf.h"
@ -10,7 +11,7 @@
/* 16-bit hashing function http://www.cse.yorku.ca/~oz/hash.html */
/* all possible attributes are hashed and checked if they are unique */
uint16_t Utilities::get_sdbm(const char * str)
uint16_t Utilities::get_sdbm(const char* str)
{
uint16_t hash = 0;
char c;
@ -23,13 +24,13 @@ uint16_t Utilities::get_sdbm(const char * str)
return hash;
}
bool Utilities::is_true(const char * s)
bool Utilities::is_true(const char* s)
{
return (!strcasecmp_P(s, PSTR("true")) || !strcasecmp_P(s, PSTR("on")) || !strcasecmp_P(s, PSTR("yes")) ||
!strcmp_P(s, PSTR("1")));
}
bool Utilities::is_only_digits(const char * s)
bool Utilities::is_only_digits(const char* s)
{
size_t digits = 0;
while(*(s + digits) != '\0' && isdigit(*(s + digits))) {
@ -38,7 +39,7 @@ bool Utilities::is_only_digits(const char * s)
return strlen(s) == digits;
}
int Utilities::format_bytes(size_t filesize, char * buf, size_t len)
int Utilities::format_bytes(size_t filesize, char* buf, size_t len)
{
if(filesize < 1024) return snprintf_P(buf, len, PSTR("%d B"), filesize);
@ -54,8 +55,44 @@ int Utilities::format_bytes(size_t filesize, char * buf, size_t len)
return snprintf_P(buf, len, PSTR("%d.%d %ciB"), filesize / 10, filesize % 10, labels[unit]);
}
std::string Utilities::tft_driver_name()
{
#if defined(ILI9341_DRIVER)
return "ILI9341";
#elif defined(ST7735_DRIVER)
return "ST7735";
#elif defined(ILI9163_DRIVER)
return "ILI9163";
#elif defined(S6D02A1_DRIVER)
return "S6D02A1";
#elif defined(ST7796_DRIVER)
return "ST7796";
#elif defined(ILI9486_DRIVER)
return "ILI9486";
#elif defined(ILI9481_DRIVER)
return "ILI9481";
#elif defined(ILI9488_DRIVER)
return "ILI9488";
#elif defined(HX8357D_DRIVER)
return "HX8357D";
#elif defined(EPD_DRIVER)
return "EPD";
#elif defined(ST7789_DRIVER)
return "ST7789";
#elif defined(R61581_DRIVER)
return "R61581";
#elif defined(ST7789_2_DRIVER)
return "ST7789_2";
#elif defined(RM68140_DRIVER)
return "RM68140";
#else
return "Other";
#endif
}
#ifndef ARDUINO
long map(long x, long in_min, long in_max, long out_min, long out_max) {
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
long map(long x, long in_min, long in_max, long out_min, long out_max)
{
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
#endif

11
src/hasp/hasp_utilities.h
View File

@ -4,13 +4,16 @@
#ifndef HASP_UTILITIES_H
#define HASP_UTILITIES_H
#include <string>
class Utilities {
public:
static uint16_t get_sdbm(const char * str);
static bool is_true(const char * s);
static bool is_only_digits(const char * s);
static int format_bytes(size_t filesize, char * buf, size_t len);
static uint16_t get_sdbm(const char* str);
static bool is_true(const char* s);
static bool is_only_digits(const char* s);
static int format_bytes(size_t filesize, char* buf, size_t len);
static std::string tft_driver_name();
};
#ifndef ARDUINO

80
src/hasp_gui.cpp
View File

@ -12,6 +12,7 @@
#include "lv_fs_if.h"
// Device Drivers
#include "dev/device.h"
#include "drv/hasp_drv_display.h"
#include "drv/hasp_drv_touch.h"
@ -111,17 +112,17 @@ void guiSetup(void)
static lv_color_t *guiVdbBuffer1, *guiVdbBuffer2 = NULL;
// DMA: len must be less than 32767
const size_t guiVDBsize = 15 * 1024u; // 30 KBytes
guiVdbBuffer1 = (lv_color_t *)heap_caps_calloc(guiVDBsize, sizeof(lv_color_t), MALLOC_CAP_DMA);
guiVdbBuffer1 = (lv_color_t*)heap_caps_calloc(guiVDBsize, sizeof(lv_color_t), MALLOC_CAP_DMA);
// guiVdbBuffer2 = (lv_color_t *)heap_caps_malloc(sizeof(lv_color_t) * guiVDBsize, MALLOC_CAP_DMA);
// lv_disp_buf_init(&disp_buf, guiVdbBuffer1, guiVdbBuffer2, guiVDBsize);
#else
static lv_color_t * guiVdbBuffer1;
static lv_color_t* guiVdbBuffer1;
const size_t guiVDBsize = 16 * 1024u; // 32 KBytes
if(0 && psramFound()) {
guiVdbBuffer1 = (lv_color_t *)ps_calloc(guiVDBsize, sizeof(lv_color_t)); // too slow for VDB
guiVdbBuffer1 = (lv_color_t*)ps_calloc(guiVDBsize, sizeof(lv_color_t)); // too slow for VDB
} else {
guiVdbBuffer1 = (lv_color_t *)calloc(guiVDBsize, sizeof(lv_color_t));
guiVdbBuffer1 = (lv_color_t*)calloc(guiVDBsize, sizeof(lv_color_t));
}
#endif
@ -135,9 +136,9 @@ void guiSetup(void)
// size_t guiVDBsize = sizeof(guiVdbBuffer1) / sizeof(guiVdbBuffer1[0]);
// lv_disp_buf_init(&disp_buf, guiVdbBuffer1, NULL, guiVDBsize);
static lv_color_t * guiVdbBuffer1;
static lv_color_t* guiVdbBuffer1;
const size_t guiVDBsize = 2 * 512u; // 4 KBytes * 2
guiVdbBuffer1 = (lv_color_t *)malloc(sizeof(lv_color_t) * guiVDBsize);
guiVdbBuffer1 = (lv_color_t*)malloc(sizeof(lv_color_t) * guiVDBsize);
#elif defined(WINDOWS)
const size_t guiVDBsize = LV_HOR_RES_MAX * 10;
@ -170,9 +171,9 @@ void guiSetup(void)
drv_display_init(&disp_drv, gui_settings.rotation,
gui_settings.invert_display); // Set display driver callback & rotation
#endif
disp_drv.hor_res = TFT_WIDTH;
disp_drv.ver_res = TFT_HEIGHT;
lv_disp_t * display = lv_disp_drv_register(&disp_drv);
disp_drv.hor_res = TFT_WIDTH;
disp_drv.ver_res = TFT_HEIGHT;
lv_disp_t* display = lv_disp_drv_register(&disp_drv);
switch(gui_settings.rotation) {
case 1:
@ -203,16 +204,17 @@ void guiSetup(void)
#endif
/* Setup Backlight Control Pin */
if(gui_settings.backlight_pin >= 0) {
LOG_VERBOSE(TAG_GUI, F("Backlight : Pin %d"), gui_settings.backlight_pin);
haspDevice.set_backlight_pin(gui_settings.backlight_pin);
// if(gui_settings.backlight_pin >= 0) {
// LOG_VERBOSE(TAG_GUI, F("Backlight : Pin %d"), gui_settings.backlight_pin);
#if defined(ARDUINO_ARCH_ESP32)
ledcSetup(BACKLIGHT_CHANNEL, 20000, 12);
ledcAttachPin(gui_settings.backlight_pin, BACKLIGHT_CHANNEL);
#elif defined(ARDUINO_ARCH_ESP8266)
pinMode(gui_settings.backlight_pin, OUTPUT);
#endif
}
// #if defined(ARDUINO_ARCH_ESP32)
// ledcSetup(BACKLIGHT_CHANNEL, 20000, 12);
// ledcAttachPin(gui_settings.backlight_pin, BACKLIGHT_CHANNEL);
// #elif defined(ARDUINO_ARCH_ESP8266)
// pinMode(gui_settings.backlight_pin, OUTPUT);
// #endif
// }
LOG_VERBOSE(TAG_GUI, F("Rotation : %d"), gui_settings.rotation);
LOG_VERBOSE(TAG_LVGL, F("Version : %u.%u.%u %s"), LVGL_VERSION_MAJOR, LVGL_VERSION_MINOR, LVGL_VERSION_PATCH,
@ -232,7 +234,7 @@ void guiSetup(void)
#else
indev_drv.read_cb = drv_touch_read;
#endif
lv_indev_t * mouse_indev = lv_indev_drv_register(&indev_drv);
lv_indev_t* mouse_indev = lv_indev_drv_register(&indev_drv);
mouse_indev->driver.type = LV_INDEV_TYPE_POINTER;
/*Set a cursor for the mouse*/
@ -242,8 +244,8 @@ void guiSetup(void)
// lv_indev_set_cursor(mouse_indev, label); // connect the object to the driver
LOG_TRACE(TAG_GUI, F("Initialize Cursor"));
lv_obj_t * cursor;
lv_obj_t * mouse_layer = lv_disp_get_layer_sys(NULL); // default display
lv_obj_t* cursor;
lv_obj_t* mouse_layer = lv_disp_get_layer_sys(NULL); // default display
#if defined(ARDUINO_ARCH_ESP32)
LV_IMG_DECLARE(mouse_cursor_icon); /*Declare the image file.*/
@ -265,7 +267,7 @@ void guiSetup(void)
/* Initialize Global progress bar*/
lv_obj_user_data_t udata = (lv_obj_user_data_t){10, 0, 10};
lv_obj_t * bar = lv_bar_create(lv_layer_sys(), NULL);
lv_obj_t* bar = lv_bar_create(lv_layer_sys(), NULL);
lv_obj_set_user_data(bar, udata);
lv_obj_set_hidden(bar, true);
lv_bar_set_range(bar, 0, 100);
@ -372,7 +374,7 @@ int8_t guiGetDim()
////////////////////////////////////////////////////////////////////////////////////////////////////
#if HASP_USE_CONFIG > 0
bool guiGetConfig(const JsonObject & settings)
bool guiGetConfig(const JsonObject& settings)
{
bool changed = false;
uint16_t guiSleepTime1;
@ -443,7 +445,7 @@ bool guiGetConfig(const JsonObject & settings)
*
* @param[in] settings JsonObject with the config settings.
**/
bool guiSetConfig(const JsonObject & settings)
bool guiSetConfig(const JsonObject& settings)
{
configOutput(settings, TAG_GUI);
bool changed = false;
@ -507,7 +509,7 @@ bool guiSetConfig(const JsonObject & settings)
/* **************************** SCREENSHOTS ************************************** */
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0 || HASP_USE_HTTP > 0
static void guiSetBmpHeader(uint8_t * buffer_p, int32_t data)
static void guiSetBmpHeader(uint8_t* buffer_p, int32_t data)
{
*buffer_p++ = data & 0xFF;
*buffer_p++ = (data >> 8) & 0xFF;
@ -522,13 +524,13 @@ static void guiSetBmpHeader(uint8_t * buffer_p, int32_t data)
* @note: send header before refreshing the whole screen
*
**/
static void gui_get_bitmap_header(uint8_t * buffer, size_t bufsize)
static void gui_get_bitmap_header(uint8_t* buffer, size_t bufsize)
{
memset(buffer, 0, bufsize);
lv_disp_t * disp = lv_disp_get_default();
buffer[0] = 0x42; // B
buffer[1] = 0x4D; // M
lv_disp_t* disp = lv_disp_get_default();
buffer[0] = 0x42; // B
buffer[1] = 0x4D; // M
buffer[10 + 0] = 122; // full header size
buffer[14 + 0] = 122 - 14; // dib header size
@ -538,7 +540,7 @@ static void gui_get_bitmap_header(uint8_t * buffer, size_t bufsize)
// The refresh draws the active screen only, so we need the dimensions of the active screen
// This could in be diferent from the display driver width/height if the screen has been resized
lv_obj_t * scr = lv_disp_get_scr_act(NULL);
lv_obj_t* scr = lv_disp_get_scr_act(NULL);
// file size
guiSetBmpHeader(&buffer[2], 122 + disp->driver.hor_res * disp->driver.ver_res * buffer[28] / 8);
@ -579,11 +581,11 @@ void gui_flush_not_complete()
#if HASP_USE_SPIFFS > 0 || HASP_USE_LITTLEFS > 0
/* Flush VDB bytes to a file */
static void gui_screenshot_to_file(lv_disp_drv_t * disp, const lv_area_t * area, lv_color_t * color_p)
static void gui_screenshot_to_file(lv_disp_drv_t* disp, const lv_area_t* area, lv_color_t* color_p)
{
size_t len = (area->x2 - area->x1 + 1) * (area->y2 - area->y1 + 1); /* Number of pixels */
len *= sizeof(lv_color_t); /* Number of bytes */
size_t res = pFileOut.write((uint8_t *)color_p, len);
size_t res = pFileOut.write((uint8_t*)color_p, len);
if(res != len) gui_flush_not_complete();
drv_display_flush_cb(disp, area, color_p); // indirect callback to flush screenshot data to the screen
}
@ -597,7 +599,7 @@ static void gui_screenshot_to_file(lv_disp_drv_t * disp, const lv_area_t * area,
* @param[in] pFileName Output binary file name.
*
**/
void guiTakeScreenshot(const char * pFileName)
void guiTakeScreenshot(const char* pFileName)
{
uint8_t buffer[128];
gui_get_bitmap_header(buffer, sizeof(buffer));
@ -610,8 +612,8 @@ void guiTakeScreenshot(const char * pFileName)
LOG_VERBOSE(TAG_GUI, F("Bitmap header written"));
/* Refresh screen to screenshot callback */
lv_disp_t * disp = lv_disp_get_default();
void (*flush_cb)(struct _disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p);
lv_disp_t* disp = lv_disp_get_default();
void (*flush_cb)(struct _disp_drv_t * disp_drv, const lv_area_t* area, lv_color_t* color_p);
flush_cb = disp->driver.flush_cb; /* store callback */
disp->driver.flush_cb = gui_screenshot_to_file;
@ -634,11 +636,11 @@ void guiTakeScreenshot(const char * pFileName)
#if HASP_USE_HTTP > 0
/* Flush VDB bytes to a webclient */
static void gui_screenshot_to_http(lv_disp_drv_t * disp, const lv_area_t * area, lv_color_t * color_p)
static void gui_screenshot_to_http(lv_disp_drv_t* disp, const lv_area_t* area, lv_color_t* color_p)
{
size_t len = (area->x2 - area->x1 + 1) * (area->y2 - area->y1 + 1); /* Number of pixels */
len *= sizeof(lv_color_t); /* Number of bytes */
size_t res = httpClientWrite((uint8_t *)color_p, len);
size_t res = httpClientWrite((uint8_t*)color_p, len);
if(res != len) gui_flush_not_complete();
drv_display_flush_cb(disp, area, color_p);
}
@ -659,8 +661,8 @@ void guiTakeScreenshot()
LOG_VERBOSE(TAG_GUI, F("Bitmap header sent"));
/* Refresh screen to screenshot callback */
lv_disp_t * disp = lv_disp_get_default();
void (*flush_cb)(struct _disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p);
lv_disp_t* disp = lv_disp_get_default();
void (*flush_cb)(struct _disp_drv_t * disp_drv, const lv_area_t* area, lv_color_t* color_p);
flush_cb = disp->driver.flush_cb; /* store callback */
disp->driver.flush_cb = gui_screenshot_to_http;
lv_obj_invalidate(lv_scr_act());

16
src/mqtt/hasp_mqtt.h
View File

@ -9,7 +9,7 @@
#include "hasp_conf.h"
#ifdef WINDOWS
#define __FlashStringHelper char
#define __FlashStringHelper char
#endif
void mqttSetup();
@ -18,18 +18,18 @@ void mqttEvery5Seconds(bool wifiIsConnected);
void mqttStart();
void mqttStop();
void mqtt_send_object_state(uint8_t pageid, uint8_t btnid, char * payload);
void mqtt_send_state(const __FlashStringHelper * subtopic, const char * payload);
void mqtt_send_object_state(uint8_t pageid, uint8_t btnid, char* payload);
void mqtt_send_state(const __FlashStringHelper* subtopic, const char* payload);
bool mqttIsConnected();
#if HASP_USE_CONFIG > 0
bool mqttGetConfig(const JsonObject & settings);
bool mqttSetConfig(const JsonObject & settings);
bool mqttGetConfig(const JsonObject& settings);
bool mqttSetConfig(const JsonObject& settings);
#endif
#ifndef WINDOWS
String mqttGetNodename(void);
#endif
// #ifndef WINDOWS
// String mqttGetNodename(void);
// #endif
#endif

192
src/mqtt/hasp_mqtt_paho.cpp
View File

@ -6,94 +6,94 @@
#include "hasp_conf.h"
#if HASP_USE_MQTT > 0
#ifdef USE_PAHO
#ifdef USE_PAHO
/*******************************************************************************
* Copyright (c) 2012, 2020 IBM Corp.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* and Eclipse Distribution License v1.0 which accompany this distribution.
*
* The Eclipse Public License is available at
* https://www.eclipse.org/legal/epl-2.0/
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Ian Craggs - initial contribution
*******************************************************************************/
/*******************************************************************************
* Copyright (c) 2012, 2020 IBM Corp.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* and Eclipse Distribution License v1.0 which accompany this distribution.
*
* The Eclipse Public License is available at
* https://www.eclipse.org/legal/epl-2.0/
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Ian Craggs - initial contribution
*******************************************************************************/
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "MQTTAsync.h"
#include "MQTTAsync.h"
#include "hasp_mqtt.h" // functions to implement here
#include "hasp_mqtt.h" // functions to implement here
#include "hasp/hasp_dispatch.h" // for dispatch_topic_payload
#include "hasp_debug.h" // for logging
#include "hasp/hasp_dispatch.h" // for dispatch_topic_payload
#include "hasp_debug.h" // for logging
#if !defined(_WIN32)
#include <unistd.h>
#else
#include <windows.h>
#endif
#if !defined(_WIN32)
#include <unistd.h>
#else
#include <windows.h>
#endif
#if defined(_WRS_KERNEL)
#include <OsWrapper.h>
#endif
#if defined(_WRS_KERNEL)
#include <OsWrapper.h>
#endif
#define ADDRESS "10.4.0.5:1883"
#define CLIENTID "ExampleClientSub"
#define TOPIC "hasp/plate35/"
#define QOS 1
#define TIMEOUT 10000L
#define ADDRESS "10.4.0.5:1883"
#define CLIENTID "ExampleClientSub"
#define TOPIC "hasp/plate35/"
#define QOS 1
#define TIMEOUT 10000L
const char * mqttNodeTopic = TOPIC;
const char * mqttGroupTopic = TOPIC;
const char* mqttNodeTopic = TOPIC;
const char* mqttGroupTopic = TOPIC;
// char mqttNodeTopic[24];
// char mqttGroupTopic[24];
bool mqttEnabled = false;
bool mqttHAautodiscover = true;
////////////////////////////////////////////////////////////////////////////////////////////////////
// These defaults may be overwritten with values saved by the web interface
#ifndef MQTT_HOST
#define MQTT_HOST "";
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////
// These defaults may be overwritten with values saved by the web interface
#ifndef MQTT_HOST
#define MQTT_HOST "";
#endif
#ifndef MQTT_PORT
#define MQTT_PORT 1883;
#endif
#ifndef MQTT_PORT
#define MQTT_PORT 1883;
#endif
#ifndef MQTT_USER
#define MQTT_USER "";
#endif
#ifndef MQTT_USER
#define MQTT_USER "";
#endif
#ifndef MQTT_PASSW
#define MQTT_PASSW "";
#endif
#ifndef MQTT_NODENAME
#define MQTT_NODENAME "";
#endif
#ifndef MQTT_GROUPNAME
#define MQTT_GROUPNAME "";
#endif
#ifndef MQTT_PASSW
#define MQTT_PASSW "";
#endif
#ifndef MQTT_NODENAME
#define MQTT_NODENAME "";
#endif
#ifndef MQTT_GROUPNAME
#define MQTT_GROUPNAME "";
#endif
#ifndef MQTT_PREFIX
#define MQTT_PREFIX "hasp"
#endif
#ifndef MQTT_PREFIX
#define MQTT_PREFIX "hasp"
#endif
#define LWT_TOPIC "LWT"
#define LWT_TOPIC "LWT"
char mqttServer[16] = MQTT_HOST;
char mqttUser[23] = MQTT_USER;
char mqttPassword[32] = MQTT_PASSW;
char mqttNodeName[16] = MQTT_NODENAME;
char mqttServer[16] = MQTT_HOST;
char mqttUser[23] = MQTT_USER;
char mqttPassword[32] = MQTT_PASSW;
// char mqttNodeName[16] = MQTT_NODENAME;
char mqttGroupName[16] = MQTT_GROUPNAME;
uint16_t mqttPort = MQTT_PORT;
@ -103,11 +103,11 @@ int disc_finished = 0;
int subscribed = 0;
int connected = 0;
static bool mqttPublish(const char * topic, const char * payload, size_t len, bool retain = false);
static bool mqttPublish(const char* topic, const char* payload, size_t len, bool retain = false);
/* ===== Paho event callbacks ===== */
void connlost(void * context, char * cause)
void connlost(void* context, char* cause)
{
printf("\nConnection lost\n");
if(cause) printf(" cause: %s\n", cause);
@ -117,7 +117,7 @@ void connlost(void * context, char * cause)
}
// Receive incoming messages
static void mqtt_message_cb(char * topic, char * payload, unsigned int length)
static void mqtt_message_cb(char* topic, char* payload, unsigned int length)
{ // Handle incoming commands from MQTT
if(length + 1 >= MQTT_MAX_PACKET_SIZE) {
LOG_ERROR(TAG_MQTT_RCV, F("Payload too long (%d bytes)"), length);
@ -126,7 +126,7 @@ static void mqtt_message_cb(char * topic, char * payload, unsigned int length)
payload[length] = '\0';
}
LOG_TRACE(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
@ -137,11 +137,11 @@ static void mqtt_message_cb(char * topic, char * payload, unsigned int length)
// Group topic
topic += strlen(mqttGroupTopic); // shorten topic
dispatch_topic_payload(topic, (const char *)payload);
dispatch_topic_payload(topic, (const char*)payload);
return;
} else if(topic == strstr_P(topic, PSTR("homeassistant/status"))) { // HA discovery topic
if(mqttHAautodiscover && !strcasecmp_P((char *)payload, PSTR("online"))) {
if(mqttHAautodiscover && !strcasecmp_P((char*)payload, PSTR("online"))) {
// dispatch_current_state();
// mqtt_ha_register_auto_discovery();
}
@ -155,7 +155,7 @@ static void mqtt_message_cb(char * topic, char * payload, unsigned int length)
// catch a dangling LWT from a previous connection if it appears
if(!strcmp_P(topic, PSTR(LWT_TOPIC))) { // endsWith LWT
if(!strcasecmp_P((char *)payload, PSTR("offline"))) {
if(!strcasecmp_P((char*)payload, PSTR("offline"))) {
{
char msg[8];
char tmp_topic[strlen(mqttNodeTopic) + 8];
@ -170,57 +170,57 @@ static void mqtt_message_cb(char * topic, char * payload, unsigned int length)
// LOG_TRACE(TAG_MQTT, F("ignoring LWT = online"));
}
} else {
dispatch_topic_payload(topic, (const char *)payload);
dispatch_topic_payload(topic, (const char*)payload);
}
}
int msgarrvd(void * context, char * topicName, int topicLen, MQTTAsync_message * message)
int msgarrvd(void* context, char* topicName, int topicLen, MQTTAsync_message* message)
{
// printf("MQT RCV >> ");
// printf("%s => %.*s (%d)\n", topicName, message->payloadlen, (char *)message->payload, message->payloadlen);
char msg[message->payloadlen + 1];
memcpy(msg, (char *)message->payload, message->payloadlen);
memcpy(msg, (char*)message->payload, message->payloadlen);
msg[message->payloadlen] = '\0';
mqtt_message_cb(topicName, (char *)message->payload, message->payloadlen);
mqtt_message_cb(topicName, (char*)message->payload, message->payloadlen);
MQTTAsync_freeMessage(&message);
MQTTAsync_free(topicName);
return 1;
}
void onDisconnectFailure(void * context, MQTTAsync_failureData * response)
void onDisconnectFailure(void* context, MQTTAsync_failureData* response)
{
printf("Disconnect failed, rc %d\n", response->code);
disc_finished = 1;
}
void onDisconnect(void * context, MQTTAsync_successData * response)
void onDisconnect(void* context, MQTTAsync_successData* response)
{
printf("Successful disconnection\n");
disc_finished = 1;
connected = 0;
}
void onSubscribe(void * context, MQTTAsync_successData * response)
void onSubscribe(void* context, MQTTAsync_successData* response)
{
printf("Subscribe succeeded %d\n", response->token);
subscribed = 1;
}
void onSubscribeFailure(void * context, MQTTAsync_failureData * response)
void onSubscribeFailure(void* context, MQTTAsync_failureData* response)
{
printf("Subscribe failed, rc %d\n", response->code);
}
void onConnectFailure(void * context, MQTTAsync_failureData * response)
void onConnectFailure(void* context, MQTTAsync_failureData* response)
{
connected = 0;
printf("Connect failed, rc %d\n", response->code);
}
void mqtt_subscribe(void * context, const char * topic)
void mqtt_subscribe(void* context, const char* topic)
{
MQTTAsync client = (MQTTAsync)context;
MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
@ -235,7 +235,7 @@ void mqtt_subscribe(void * context, const char * topic)
}
}
void onConnect(void * context, MQTTAsync_successData * response)
void onConnect(void* context, MQTTAsync_successData* response)
{
MQTTAsync client = (MQTTAsync)context;
connected = 1;
@ -253,7 +253,7 @@ void onConnect(void * context, MQTTAsync_successData * response)
std::cout << std::endl;
}
void onSendFailure(void * context, MQTTAsync_failureData * response)
void onSendFailure(void* context, MQTTAsync_failureData* response)
{
MQTTAsync client = (MQTTAsync)context;
MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer;
@ -265,11 +265,11 @@ void onSendFailure(void * context, MQTTAsync_failureData * response)
opts.context = client;
if((rc = MQTTAsync_disconnect(client, &opts)) != MQTTASYNC_SUCCESS) {
printf("Failed to start disconnect, return code %d\n", rc);
//exit(EXIT_FAILURE);
// exit(EXIT_FAILURE);
}
}
void onSend(void * context, MQTTAsync_successData * response)
void onSend(void* context, MQTTAsync_successData* response)
{
MQTTAsync client = (MQTTAsync)context;
MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer;
@ -289,7 +289,7 @@ void onSend(void * context, MQTTAsync_successData * response)
/* ===== Local HASP MQTT functions ===== */
static bool mqttPublish(const char * topic, const char * payload, size_t len, bool retain)
static bool mqttPublish(const char* topic, const char* payload, size_t len, bool retain)
{
if(mqttIsConnected()) {
MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
@ -299,7 +299,7 @@ static bool mqttPublish(const char * topic, const char * payload, size_t len, bo
opts.onSuccess = onSend;
opts.onFailure = onSendFailure;
opts.context = mqtt_client;
pubmsg.payload = (char *)payload;
pubmsg.payload = (char*)payload;
pubmsg.payloadlen = (int)strlen(payload);
pubmsg.qos = QOS;
pubmsg.retained = 0;
@ -322,7 +322,7 @@ bool mqttIsConnected()
return connected == 1;
}
void mqtt_send_state(const __FlashStringHelper * subtopic, const char * payload)
void mqtt_send_state(const __FlashStringHelper* subtopic, const char* payload)
{
char tmp_topic[strlen(mqttNodeTopic) + 20];
printf(("%sstate/%s\n"), mqttNodeTopic, subtopic);
@ -330,7 +330,7 @@ void mqtt_send_state(const __FlashStringHelper * subtopic, const char * payload)
mqttPublish(tmp_topic, payload, false);
}
void mqtt_send_object_state(uint8_t pageid, uint8_t btnid, char * payload)
void mqtt_send_object_state(uint8_t pageid, uint8_t btnid, char* payload)
{
char tmp_topic[strlen(mqttNodeTopic) + 20];
snprintf_P(tmp_topic, sizeof(tmp_topic), PSTR("%sstate/p%ub%u"), mqttNodeTopic, pageid, btnid);
@ -419,7 +419,5 @@ void mqttLoop(){};
void mqttEvery5Seconds(bool wifiIsConnected){};
// String mqttGetNodename(void){return "palte35"};
#endif // USE_PAHO
#endif // USE_MQTT
#endif // USE_PAHO
#endif // USE_MQTT

150
src/mqtt/hasp_mqtt_pubsubclient.cpp
View File

@ -4,82 +4,82 @@
#include "hasp_conf.h"
#if HASP_USE_MQTT > 0
#ifdef USE_PUBSUBCLIENT
#ifdef USE_PUBSUBCLIENT
#include "PubSubClient.h"
#include "PubSubClient.h"
#include "hasp/hasp.h"
#include "hasp_mqtt.h"
#include "hasp_mqtt_ha.h"
#include "hasp/hasp.h"
#include "hasp_mqtt.h"
#include "hasp_mqtt_ha.h"
#if defined(ARDUINO_ARCH_ESP32)
#include <WiFi.h>
#if defined(ARDUINO_ARCH_ESP32)
#include <WiFi.h>
WiFiClient mqttNetworkClient;
#elif defined(ARDUINO_ARCH_ESP8266)
#include <ESP8266WiFi.h>
#include <EEPROM.h>
#include <Esp.h>
#elif defined(ARDUINO_ARCH_ESP8266)
#include <ESP8266WiFi.h>
#include <EEPROM.h>
#include <Esp.h>
WiFiClient mqttNetworkClient;
#else
#if defined(STM32F4xx) && HASP_USE_WIFI > 0
#else
#if defined(STM32F4xx) && HASP_USE_WIFI > 0
// #include <WiFi.h>
WiFiSpiClient mqttNetworkClient;
#else
#if defined(W5500_MOSI) && defined(W5500_MISO) && defined(W5500_SCLK)
#define W5500_LAN
#include <Ethernet.h>
#else
#include <STM32Ethernet.h>
#endif
#else
#if defined(W5500_MOSI) && defined(W5500_MISO) && defined(W5500_SCLK)
#define W5500_LAN
#include <Ethernet.h>
#else
#include <STM32Ethernet.h>
#endif
EthernetClient mqttNetworkClient;
#endif
#endif
#endif
#endif
#include "hal/hasp_hal.h"
#include "hasp_debug.h"
#include "hasp_config.h"
#include "hal/hasp_hal.h"
#include "hasp_debug.h"
#include "hasp_config.h"
#include "../hasp/hasp_dispatch.h"
#include "../hasp/hasp_dispatch.h"
#ifdef USE_CONFIG_OVERRIDE
#include "user_config_override.h"
#endif
#ifdef USE_CONFIG_OVERRIDE
#include "user_config_override.h"
#endif
char mqttNodeTopic[24];
char mqttGroupTopic[24];
bool mqttEnabled = false;
bool mqttHAautodiscover = true;
////////////////////////////////////////////////////////////////////////////////////////////////////
// These defaults may be overwritten with values saved by the web interface
#ifndef MQTT_HOST
#define MQTT_HOST "";
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////
// These defaults may be overwritten with values saved by the web interface
#ifndef MQTT_HOST
#define MQTT_HOST "";
#endif
#ifndef MQTT_PORT
#define MQTT_PORT 1883;
#endif
#ifndef MQTT_PORT
#define MQTT_PORT 1883;
#endif
#ifndef MQTT_USER
#define MQTT_USER "";
#endif
#ifndef MQTT_USER
#define MQTT_USER "";
#endif
#ifndef MQTT_PASSW
#define MQTT_PASSW "";
#endif
#ifndef MQTT_NODENAME
#define MQTT_NODENAME "";
#endif
#ifndef MQTT_GROUPNAME
#define MQTT_GROUPNAME "";
#endif
#ifndef MQTT_PASSW
#define MQTT_PASSW "";
#endif
#ifndef MQTT_NODENAME
#define MQTT_NODENAME "";
#endif
#ifndef MQTT_GROUPNAME
#define MQTT_GROUPNAME "";
#endif
#ifndef MQTT_PREFIX
#define MQTT_PREFIX "hasp"
#endif
#ifndef MQTT_PREFIX
#define MQTT_PREFIX "hasp"
#endif
#define LWT_TOPIC "LWT"
#define LWT_TOPIC "LWT"
char mqttServer[16] = MQTT_HOST;
char mqttUser[23] = MQTT_USER;
@ -89,11 +89,11 @@ char mqttGroupName[16] = MQTT_GROUPNAME;
uint16_t mqttPort = MQTT_PORT;
PubSubClient mqttClient(mqttNetworkClient);
static bool mqttPublish(const char * topic, const char * payload, size_t len, bool retain = false)
static bool mqttPublish(const char* topic, const char* payload, size_t len, bool retain = false)
{
if(mqttIsConnected()) {
if(mqttClient.beginPublish(topic, len, retain)) {
mqttClient.write((uint8_t *)payload, len);
mqttClient.write((uint8_t*)payload, len);
mqttClient.endPublish();
LOG_TRACE(TAG_MQTT_PUB, F("%s => %s"), topic, payload);
@ -107,7 +107,7 @@ static bool mqttPublish(const char * topic, const char * payload, size_t len, bo
return false;
}
static bool mqttPublish(const char * topic, const char * payload, bool retain = false)
static bool mqttPublish(const char* topic, const char* payload, bool retain = false)
{
return mqttPublish(topic, payload, strlen(payload), retain);
}
@ -132,14 +132,14 @@ void mqtt_send_lwt(bool online)
bool res = mqttPublish(tmp_topic, tmp_payload, len, true);
}
void mqtt_send_object_state(uint8_t pageid, uint8_t btnid, char * payload)
void mqtt_send_object_state(uint8_t pageid, uint8_t btnid, char* payload)
{
char tmp_topic[strlen(mqttNodeTopic) + 16];
snprintf_P(tmp_topic, sizeof(tmp_topic), PSTR("%sstate/" HASP_OBJECT_NOTATION), mqttNodeTopic, pageid, btnid);
mqttPublish(tmp_topic, payload);
}
void mqtt_send_state(const __FlashStringHelper * subtopic, const char * payload)
void mqtt_send_state(const __FlashStringHelper* subtopic, const char* payload)
{
char tmp_topic[strlen(mqttNodeTopic) + 20];
snprintf_P(tmp_topic, sizeof(tmp_topic), PSTR("%sstate/%s"), mqttNodeTopic, subtopic);
@ -148,7 +148,7 @@ void mqtt_send_state(const __FlashStringHelper * subtopic, const char * payload)
////////////////////////////////////////////////////////////////////////////////////////////////////
// Receive incoming messages
static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
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);
@ -157,7 +157,7 @@ static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
payload[length] = '\0';
}
LOG_TRACE(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
@ -168,11 +168,11 @@ static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
// Group topic
topic += strlen(mqttGroupTopic); // shorten topic
dispatch_topic_payload(topic, (const char *)payload);
dispatch_topic_payload(topic, (const char*)payload);
return;
} else if(topic == strstr_P(topic, PSTR("homeassistant/status"))) { // HA discovery topic
if(mqttHAautodiscover && !strcasecmp_P((char *)payload, PSTR("online"))) {
if(mqttHAautodiscover && !strcasecmp_P((char*)payload, PSTR("online"))) {
dispatch_current_state();
mqtt_ha_register_auto_discovery();
}
@ -186,7 +186,7 @@ static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
// catch a dangling LWT from a previous connection if it appears
if(!strcmp_P(topic, PSTR(LWT_TOPIC))) { // endsWith LWT
if(!strcasecmp_P((char *)payload, PSTR("offline"))) {
if(!strcasecmp_P((char*)payload, PSTR("offline"))) {
{
char msg[8];
char tmp_topic[strlen(mqttNodeTopic) + 8];
@ -201,11 +201,11 @@ static void mqtt_message_cb(char * topic, byte * payload, unsigned int length)
// LOG_TRACE(TAG_MQTT, F("ignoring LWT = online"));
}
} else {
dispatch_topic_payload(topic, (const char *)payload);
dispatch_topic_payload(topic, (const char*)payload);
}
}
static void mqttSubscribeTo(const __FlashStringHelper * format, const char * data)
static void mqttSubscribeTo(const __FlashStringHelper* format, const char* data)
{
char tmp_topic[strlen_P((PGM_P)format) + 2 + strlen(data)];
snprintf_P(tmp_topic, sizeof(tmp_topic), (PGM_P)format, data);
@ -290,7 +290,7 @@ void mqttStart()
LOG_INFO(TAG_MQTT, F(D_MQTT_CONNECTED), mqttServer, mqttClientId);
// Subscribe to our incoming topics
const __FlashStringHelper * F_topic;
const __FlashStringHelper* F_topic;
F_topic = F("%scommand/#");
mqttSubscribeTo(F_topic, mqttGroupTopic);
mqttSubscribeTo(F_topic, mqttNodeTopic);
@ -348,10 +348,10 @@ void mqttEvery5Seconds(bool networkIsConnected)
}
}
String mqttGetNodename()
{
return mqttNodeName;
}
// String mqttGetNodename()
// {
// return mqttNodeName;
// }
void mqttStop()
{
@ -363,8 +363,8 @@ void mqttStop()
}
}
#if HASP_USE_CONFIG > 0
bool mqttGetConfig(const JsonObject & settings)
#if HASP_USE_CONFIG > 0
bool mqttGetConfig(const JsonObject& settings)
{
bool changed = false;
@ -398,7 +398,7 @@ bool mqttGetConfig(const JsonObject & settings)
*
* @param[in] settings JsonObject with the config settings.
**/
bool mqttSetConfig(const JsonObject & settings)
bool mqttSetConfig(const JsonObject& settings)
{
configOutput(settings, TAG_MQTT);
bool changed = false;
@ -448,8 +448,8 @@ bool mqttSetConfig(const JsonObject & settings)
return changed;
}
#endif // HASP_USE_CONFIG
#endif // HASP_USE_CONFIG
#endif // PUBSUBCLIENT
#endif // PUBSUBCLIENT
#endif // HASP_USE_MQTT

9
src/sys/net/hasp_ethernet_esp32.cpp
View File

@ -1,7 +1,6 @@
/* MIT License - Copyright (c) 2020 Francis Van Roie
For full license information read the LICENSE file in the project folder */
#include "hasp_conf.h"
#include "hal/hasp_hal.h"
#include "hasp_debug.h"
@ -17,7 +16,7 @@ void EthernetEvent(WiFiEvent_t event)
case SYSTEM_EVENT_ETH_START:
LOG_TRACE(TAG_ETH, F(D_SERVICE_STARTED));
// set eth hostname here
ETH.setHostname(mqttGetNodename().c_str());
ETH.setHostname(haspDevice.get_hostname());
break;
case SYSTEM_EVENT_ETH_CONNECTED:
LOG_TRACE(TAG_ETH, F(D_SERVICE_CONNECTED));
@ -63,10 +62,10 @@ bool ethernetEvery5Seconds()
return eth_connected;
}
void ethernet_get_statusupdate(char * buffer, size_t len)
void ethernet_get_statusupdate(char* buffer, size_t len)
{
snprintf_P(buffer, len, PSTR("\"eth\":\"%s\",\"link\":\"%d Mbps\",\"ip\":\"%s\","), eth_connected ? F("ON") : F("OFF"), ETH.linkSpeed(),
ETH.localIP().toString().c_str());
snprintf_P(buffer, len, PSTR("\"eth\":\"%s\",\"link\":\"%d Mbps\",\"ip\":\"%s\","),
eth_connected ? F("ON") : F("OFF"), ETH.linkSpeed(), ETH.localIP().toString().c_str());
}
#endif

25
src/sys/net/hasp_wifi.cpp
View File

@ -65,11 +65,12 @@ static void wifiConnected(IPAddress ipaddress)
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();
}
static void wifiDisconnected(const char * ssid, uint8_t reason)
static void wifiDisconnected(const char* ssid, uint8_t reason)
{
wifiReconnectCounter++;
@ -270,7 +271,7 @@ static void wifiDisconnected(const char * ssid, uint8_t reason)
LOG_WARNING(TAG_WIFI, F("Disconnected from %s (Reason: %s [%d])"), ssid, buffer, reason);
}
static void wifiSsidConnected(const char * ssid)
static void wifiSsidConnected(const char* ssid)
{
LOG_TRACE(TAG_WIFI, F("Connected to SSID %s. Requesting IP..."), ssid);
wifiReconnectCounter = 0;
@ -281,13 +282,13 @@ static void wifi_callback(system_event_id_t event, system_event_info_t info)
{
switch(event) {
case SYSTEM_EVENT_STA_CONNECTED:
wifiSsidConnected((const char *)info.connected.ssid);
wifiSsidConnected((const char*)info.connected.ssid);
break;
case SYSTEM_EVENT_STA_GOT_IP:
wifiConnected(IPAddress(info.got_ip.ip_info.ip.addr));
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
wifiDisconnected((const char *)info.disconnected.ssid, info.disconnected.reason);
wifiDisconnected((const char*)info.disconnected.ssid, info.disconnected.reason);
// NTP.stop(); // NTP sync can be disabled to avoid sync errors
break;
default:
@ -325,7 +326,7 @@ bool wifiShowAP()
return true;
}
bool wifiShowAP(char * ssid, char * pass)
bool wifiShowAP(char* ssid, char* pass)
{
if(strlen(wifiSsid) != 0) return false;
@ -353,10 +354,10 @@ static void wifiReconnect(void)
{
WiFi.disconnect(true);
#if defined(ARDUINO_ARCH_ESP8266)
WiFi.hostname(mqttGetNodename().c_str());
WiFi.hostname(haspDevice.get_hostname());
#elif defined(ARDUINO_ARCH_ESP32)
WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE);
WiFi.setHostname(mqttGetNodename().c_str());
WiFi.setHostname(haspDevice.get_hostname());
#endif
WiFi.begin(wifiSsid, wifiPassword);
}
@ -451,7 +452,7 @@ bool wifiEvery5Seconds()
}
}
bool wifiValidateSsid(const char * ssid, const char * pass)
bool wifiValidateSsid(const char* ssid, const char* pass)
{
uint8_t attempt = 0;
WiFi.begin(ssid, pass);
@ -493,7 +494,7 @@ void wifiStop()
LOG_WARNING(TAG_WIFI, F(D_SERVICE_STOPPED));
}
void wifi_get_statusupdate(char * buffer, size_t len)
void wifi_get_statusupdate(char* buffer, size_t len)
{
#if defined(STM32F4xx)
IPAddress ip;
@ -510,7 +511,7 @@ void wifi_get_statusupdate(char * buffer, size_t len)
/* ============ Confiuration =============================================================== */
#if HASP_USE_CONFIG > 0
bool wifiGetConfig(const JsonObject & settings)
bool wifiGetConfig(const JsonObject& settings)
{
bool changed = false;
@ -532,7 +533,7 @@ bool wifiGetConfig(const JsonObject & settings)
*
* @param[in] settings JsonObject with the config settings.
**/
bool wifiSetConfig(const JsonObject & settings)
bool wifiSetConfig(const JsonObject& settings)
{
configOutput(settings, TAG_WIFI);
bool changed = false;

42
src/sys/svc/hasp_mdns.cpp
View File

@ -4,16 +4,16 @@
#include "hasp_conf.h"
#if HASP_USE_MDNS > 0
#if defined(ARDUINO_ARCH_ESP32)
#include <ESPmDNS.h>
#elif defined(ARDUINO_ARCH_ESP8266)
#include <ESP8266mDNS.h>
// MDNSResponder::hMDNSService hMDNSService;
#endif
#if defined(ARDUINO_ARCH_ESP32)
#include <ESPmDNS.h>
#elif defined(ARDUINO_ARCH_ESP8266)
#include <ESP8266mDNS.h>
// MDNSResponder::hMDNSService hMDNSService;
#endif
#include "hasp/hasp.h"
#include "hasp_config.h"
#include "hasp_debug.h"
#include "hasp/hasp.h"
#include "hasp_config.h"
#include "hasp_debug.h"
// uint8_t mdnsEnabled = true;
hasp_mdns_config_t mdns_config;
@ -33,12 +33,6 @@ void mdnsStart()
LOG_TRACE(TAG_MDNS, F(D_SERVICE_STARTING));
#if HASP_USE_MQTT > 0
String hasp2Node = mqttGetNodename();
#else
String hasp2Node = "unknown";
#endif
// Setup mDNS service discovery if enabled
/* uint8_t attempt = 0;
@ -55,7 +49,7 @@ void mdnsStart()
LOG_VERBOSE(TAG_MDNS, F("Trying hostname %s"), hasp2Node.c_str());
};*/
if(MDNS.begin(hasp2Node.c_str())) {
if(MDNS.begin(haspDevice.get_hostname())) {
char value[32];
char service[12];
char key[12];
@ -86,23 +80,23 @@ void mdnsStart()
void mdnsLoop(void)
{
#if defined(ARDUINO_ARCH_ESP8266)
#if defined(ARDUINO_ARCH_ESP8266)
if(mdns_config.enable) {
MDNS.update();
}
#endif
#endif
}
void mdnsStop()
{
return;
#if HASP_USE_MDNS > 0
#if HASP_USE_MDNS > 0
MDNS.end();
#endif
#endif
}
#if HASP_USE_CONFIG > 0
bool mdnsGetConfig(const JsonObject & settings)
#if HASP_USE_CONFIG > 0
bool mdnsGetConfig(const JsonObject& settings)
{
bool changed = false;
@ -118,7 +112,7 @@ bool mdnsGetConfig(const JsonObject & settings)
* @note: data pixel should be formated to uint32_t RGBA. Imagemagick requirements.
* @param[in] settings JsonObject with the config settings.
**/
bool mdnsSetConfig(const JsonObject & settings)
bool mdnsSetConfig(const JsonObject& settings)
{
configOutput(settings, TAG_MDNS);
bool changed = false;
@ -127,6 +121,6 @@ bool mdnsSetConfig(const JsonObject & settings)
return changed;
}
#endif // HASP_USE_CONFIG
#endif // HASP_USE_CONFIG
#endif // HASP_USE_MDNS

12
src/sys/svc/hasp_ota.cpp
View File

@ -141,12 +141,8 @@ void otaSetup(void)
// delay(5000);
});
#if HASP_USE_MQTT > 0
ArduinoOTA.setHostname(String(mqttGetNodename()).c_str());
#else
ArduinoOTA.setHostname(String(mqttGetNodename()).c_str());
#endif
// ArduinoOTA.setPassword(configPassword);
ArduinoOTA.setHostname(haspDevice.get_hostname());
// ArduinoOTA.setPassword(configPassword); // See OTA_PASSWORD
ArduinoOTA.setPort(otaPort);
#if ESP32
@ -160,7 +156,7 @@ void otaSetup(void)
ArduinoOTA.setRebootOnSuccess(false); // We do that ourselves
#ifdef OTA_PASSWORD
ArduinoOTA.setPassword(OTA_PASSWORD);
ArduinoOTA.setPassword(OTA_PASSWORD); // TODO
#endif
ArduinoOTA.begin();
@ -180,7 +176,7 @@ void otaEverySecond(void)
if(otaPrecentageComplete >= 0) otaProgress();
}
void otaHttpUpdate(const char * espOtaUrl)
void otaHttpUpdate(const char* espOtaUrl)
{ // Update ESP firmware from HTTP
#if HASP_USE_MDNS > 0
mdnsStop(); // Keep mDNS responder from breaking things

17
user_setups/win32/emulator_64bits.ini
View File

@ -76,7 +76,11 @@ lib_deps =
https://github.com/eclipse/paho.mqtt.c.git
bblanchon/ArduinoJson@^6.17.2 ; Json(l) parser
lib_ignore = paho
lib_ignore =
paho
AXP192
ArduinoLog
lv_fs_if
src_filter =
+<*>
@ -89,14 +93,12 @@ src_filter =
-<MQTTClient.c>
-<MQTTVersion.c>
-<SSLSocket.c>
-<../.pio/libdeps/emulator_64bits/lv_fs_if/lv_fs_pc.c>
-<../.pio/libdeps/emulator_64bits/ArduinoLog/ArduinoLog.cpp>
-<sys/>
-<hal/>
-<drv/>
-<drv/touch>
-<drv/tft>
-<dev/>
+<dev/>
-<hal/>
-<svc/>
-<hasp_filesystem.cpp>
@ -105,11 +107,4 @@ src_filter =
+<lang/>
-<log/>
+<mqtt/>
-<lib/ArduinoLog>
-<lib/lv_fs_if>
-<../lib/lv_fs_if/>
-<../lib/lv_fs_if/lv_fs_if.cpp>
-<../lib/lv_fs_if/lv_fs_if.h>
-<../lib/lv_fs_if/lv_fs_spiffs.cpp>
-<../lib/lv_fs_if/lv_fs_spiffs.h>
+<../.pio/libdeps/emulator_64bits/ArduinoJson/src/ArduinoJson.h>