iotmanager/IoTManager
1
0
Fork 0
mirror of https://github.com/IoTManagerProject/IoTManager.git synced 2026-03-27 06:32:19 +03:00
Code Issues Packages Projects Releases Wiki Activity

delete

Browse Source
This commit is contained in:
Dmitry Borisenko
2021-12-22 14:06:24 +01:00
parent 1ed5c81eb7
commit 5e9b15e7de
483 changed files with 0 additions and 28088 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
include/BufferExecute.h
View File

@@ -1,20 +0,0 @@
#pragma once
#include <Arduino.h>
extern void loopCmdAdd(const String& cmdStr);
extern void fileCmdExecute(const String& filename);
extern void csvCmdExecute(String& cmdStr);
extern void spaceCmdExecute(String& cmdStr);
extern void loopCmdExecute();
extern void addKey(String& key, String& keyNumberTable, int number);
extern int getKeyNum(String& key, String& keyNumberTable);
extern void buttonIn();
extern void buttonInSet();

4
include/Bus.h
View File

@@ -1,4 +0,0 @@
#pragma once
#include <Arduino.h>
void busInit();
String i2c_scan();

26
include/Class/CallBackTest.h
View File

@@ -1,26 +0,0 @@
#pragma once
#include <Arduino.h>
#include <stdint.h>
#include <functional>
// Декларируем тип - сигнатуру метода , который мы готовы принять в данном случае это
// должен быть метод без результата и без параметров.
// Новый тип мы называем AsynсActionCb - хотя можешь назвать вообще как нравиться а что значит callBack
typedef std::function<void()> AsyncActionCb; //метод без результата и параметров
typedef std::function<bool(const String)> AsyncParamActionCb; //метод без результата и параметров
class CallBackTest {
private:
long count;
AsyncActionCb _cb;
AsyncParamActionCb _pcb;
public:
CallBackTest();
void loop();
void setCallback(AsyncActionCb cb);
void setCallback(AsyncParamActionCb pcb);
};
//extern CallBackTest* CB;

291
include/Class/LineParsing.h
View File

@@ -1,291 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Global.h"
#include "ItemsList.h"
#include "Utils/JsonUtils.h"
class LineParsing {
protected:
String _key;
String _file;
String _page;
String _descr;
String _order;
String _addr;
String _reg;
String _pin;
String _map;
String _c;
String _k;
String _inv;
String _state;
String _db;
String _type;
String _int;
String _cnt;
String _val;
String _index;
String _tm1;
String _tm2;
int pinErrors;
public:
LineParsing() :
_key{""},
_file{""},
_page{""},
_descr{""},
_order{""},
_addr{""},
_reg{""},
_pin{""},
_map{""},
_c{""},
_k{""},
_inv{""},
_state{""},
_db{""},
_type{""},
_int{""},
_cnt{""},
_val{""},
_index{""},
_tm1{""},
_tm2{""},
pinErrors{0}
{};
void update() {
//String order = sCmd.order();
//SerialPrint("I","module","create '" + order + "'");
for (int i = 1; i < 12; i++) {
if (i == 1) _key = sCmd.next();
if (i == 2) _file = sCmd.next();
if (i == 3) _page = sCmd.next();
if (i == 4) _descr = sCmd.next();
if (i == 5) _order = sCmd.next();
}
for (int i = 1; i < 10; i++) {
String arg = sCmd.next();
if (arg != "") {
if (arg.indexOf("pin[") != -1) {
_pin = extractInner(arg);
}
if (arg.indexOf("inv[") != -1) {
_inv = extractInner(arg);
}
if (arg.indexOf("st[") != -1) {
_state = extractInner(arg);
}
if (arg.indexOf("db[") != -1) {
_db = extractInner(arg);
}
if (arg.indexOf("map[") != -1) {
_map = extractInner(arg);
}
if (arg.indexOf("c[") != -1) {
_c = extractInner(arg);
}
if (arg.indexOf("k[") != -1) {
_k = extractInner(arg);
}
if (arg.indexOf("type[") != -1) {
_type = extractInner(arg);
}
if (arg.indexOf("addr[") != -1) {
_addr = extractInner(arg);
}
if (arg.indexOf("reg[") != -1) {
_reg = extractInner(arg);
}
if (arg.indexOf("int[") != -1) {
_int = extractInner(arg);
}
if (arg.indexOf("cnt[") != -1) {
_cnt = extractInner(arg);
}
if (arg.indexOf("val[") != -1) {
_val = extractInner(arg);
}
if (arg.indexOf("index[") != -1) {
_index = extractInner(arg);
}
if (arg.indexOf("tm1[") != -1) {
_tm1 = extractInner(arg);
}
if (arg.indexOf("tm2[") != -1) {
_tm2 = extractInner(arg);
}
}
}
if (_pin != "") {
if (_pin.indexOf(",") == -1) {
if (!isPinExist(_pin.toInt()) || !isDigitStr(_pin)) {
pinErrors++;
_pin = "";
}
} else {
String pin1 = selectToMarker(_pin, ",");
String pin2 = deleteBeforeDelimiter(_pin, ",");
if (!isPinExist(pin1.toInt()) || !isDigitStr(pin1) || !isPinExist(pin2.toInt()) || !isDigitStr(pin2)) {
pinErrors++;
_pin = "";
}
}
}
_page.replace("#", " ");
_descr.replace("#", " ");
_descr.replace("%ver%", String(FIRMWARE_VERSION));
_descr.replace("%name%", jsonReadStr(configSetupJson, F("name")));
createWidget(_descr, _page, _order, _file, _key);
}
String gkey() {
return _key;
}
String gfile() {
return _file;
}
String gpage() {
return _page;
}
String gdescr() {
return _descr;
}
String gorder() {
return _order;
}
String gpin() {
return _pin;
}
String ginv() {
return _inv;
}
String gstate() {
return _state;
}
String gmap() {
return _map;
}
String gc() {
return _c;
}
String gk() {
return _k;
}
String gtype() {
return _type;
}
String gaddr() {
return _addr;
}
String gregaddr() {
return _reg;
}
String gint() {
return _int;
}
String gcnt() {
return _cnt;
}
String gval() {
return _val;
}
String gindex() {
return _index;
}
String gtm1() {
return _tm1;
}
String gtm2() {
return _tm2;
}
int getPinErrors() {
return pinErrors;
}
void clearErrors() {
pinErrors = 0;
}
void clear() {
_key = "";
_file = "";
_page = "";
_descr = "";
_order = "";
_addr = "";
_reg = "";
_pin = "";
_map = "";
_c = "";
_k = "";
_inv = "";
_state = "";
_db = "";
_type = "";
_int = "";
_cnt = "";
_val = "";
_index = "";
}
String extractInnerDigit(String str) {
int p1 = str.indexOf("[");
int p2 = str.indexOf("]");
return str.substring(p1 + 1, p2);
}
void createWidget(String descr, String page, String order, String filename, String topic) {
if (filename != "na") {
String buf = "{}";
if (!loadWidget(filename, buf)) {
return;
}
if (_cnt != "") {
if (filename.indexOf("chart") != -1) jsonWriteStr(buf, "maxCount", _cnt);
}
#ifdef GATE_MODE
jsonWriteStr(buf, "info", " ");
#endif
jsonWriteStr(buf, "page", page);
jsonWriteStr(buf, "order", order);
jsonWriteStr(buf, "descr", descr);
jsonWriteStr(buf, "topic", prex + "/" + topic);
#ifdef LAYOUT_IN_RAM
all_widgets += widget + "\r\n";
#else
addFileLn("layout.txt", buf);
#endif
}
}
bool loadWidget(const String& filename, String& buf) {
buf = readFile(getWidgetFile(filename), 2048);
bool res = !(buf == "Failed" || buf == "Large");
if (!res) {
SerialPrint("E","module","on load" + filename);
}
return res;
}
const String getWidgetFile(const String& name) {
return "/widgets/" + name + ".json";
}
};
extern LineParsing myLineParsing;

32
include/Class/NotAsync.h
View File

@@ -1,32 +0,0 @@
#pragma once
#include <Arduino.h>
#include <stdint.h>
#include <functional>
typedef std::function<void(void*)> NotAsyncCb;
struct NotAsyncItem {
bool test;
NotAsyncCb cb;
void* cb_arg;
volatile bool is_used = false;
};
class NotAsync {
private:
uint8_t size;
uint8_t task = 0;
NotAsyncItem* items = NULL;
void handle(NotAsyncCb f, void* arg);
public:
NotAsync(uint8_t size);
~NotAsync();
void add(uint8_t i, NotAsyncCb, void* arg);
void make(uint8_t task);
void loop();
};
extern NotAsync* myNotAsyncActions;

257
include/Class/ScenarioClass3.h
View File

@@ -1,257 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Cmd.h"
#include "Global.h"
class Scenario {
public:
void loop2() {
if (!jsonReadBool(configSetupJson, "scen")) {
return;
}
String allBlocks = scenario;
allBlocks += "\n";
String incommingEvent = selectToMarker(eventBuf, ",");
String incommingEventKey = selectToMarker(incommingEvent, " ");
String incommingEventValue = selectToMarkerLast(incommingEvent, " ");
while (allBlocks.length()) {
String oneBlock = selectToMarker(allBlocks, "end\n");
String condition = selectToMarker(oneBlock, "\n");
//логическое и
if (condition.indexOf("&&") != -1) {
condition = condition += " && ";
//посчитаем количество условий
int conditionCnt = itemsCount2(condition, "&&") - 1;
//создадим и заполним динамический массив
bool *arr = new bool[conditionCnt];
for (int i = 0; i < conditionCnt; i++) {
arr[i] = false;
}
//есть ли входящее событие хотя бы в одном из условий и удавлетварено ли оно?
int evenInConditionNum = -1;
for (int i = 0; i < conditionCnt; i++) {
String buf = selectFromMarkerToMarker(condition, " && ", i);
if (isScenarioNeedToDo(buf, incommingEventKey, incommingEventValue, 1)) {
arr[i] = true;
evenInConditionNum = i;
}
}
//если да то проверяем остальные условия по json
if (evenInConditionNum >= 0) {
for (int i = 0; i < conditionCnt; i++) {
String buf = selectFromMarkerToMarker(condition, " && ", i);
if (i != evenInConditionNum) {
if (isScenarioNeedToDoJson(buf)) {
arr[i] = true;
}
}
}
}
//все элементы массива должны быть true
bool result = true;
for (int i = 0; i < conditionCnt; i++) {
if (!arr[i]) {
result = false;
}
}
delete[] arr;
if (result) {
oneBlock = deleteBeforeDelimiter(oneBlock, "\n");
oneBlock.replace("end", "");
//SerialPrint("I", "Event done", incommingEvent);
SerialPrint("I", F("Scenario"), F("All conditions are matched"));
spaceCmdExecute(oneBlock);
}
//логическое или
} else if (condition.indexOf("||") != -1) {
condition = condition += " || ";
//посчитаем количество условий
int conditionCnt = itemsCount2(condition, "||") - 1;
//создадим и заполним динамический массив
bool *arr = new bool[conditionCnt];
for (int i = 0; i < conditionCnt; i++) {
arr[i] = false;
}
//есть ли входящее событие хотя бы в одном из условий и удавлетварено ли оно?
int evenInConditionNum = -1;
for (int i = 0; i < conditionCnt; i++) {
String buf = selectFromMarkerToMarker(condition, " || ", i);
if (isScenarioNeedToDo(buf, incommingEventKey, incommingEventValue, 1)) {
arr[i] = true;
evenInConditionNum = i;
}
}
//если да то проверяем остальные условия по json
if (evenInConditionNum >= 0) {
for (int i = 0; i < conditionCnt; i++) {
String buf = selectFromMarkerToMarker(condition, " || ", i);
if (i != evenInConditionNum) {
if (isScenarioNeedToDoJson(buf)) {
arr[i] = true;
}
}
}
}
//хотя бы один элемент массива должн быть true
bool result = false;
for (int i = 0; i < conditionCnt; i++) {
if (arr[i]) {
result = true;
}
}
delete[] arr;
if (result) {
oneBlock = deleteBeforeDelimiter(oneBlock, "\n");
oneBlock.replace("end", "");
//SerialPrint("I", "Event done", incommingEvent);
SerialPrint("I", F("Scenario"), F("One of all condition are matched"));
spaceCmdExecute(oneBlock);
}
//если гистерезис
} else if (condition.indexOf("+-") != -1) {
if (isScenarioNeedToDo(condition, incommingEventKey, incommingEventValue, 2)) {
oneBlock = deleteBeforeDelimiter(oneBlock, "\n");
oneBlock.replace("end", "");
//SerialPrint("I", "Event done", incommingEvent);
SerialPrint("I", F("Scenario"), "Condition are matched: " + condition);
spaceCmdExecute(oneBlock);
}
//остальные случаи
} else {
if (isScenarioNeedToDo(condition, incommingEventKey, incommingEventValue, 1)) {
oneBlock = deleteBeforeDelimiter(oneBlock, "\n");
oneBlock.replace("end", "");
//SerialPrint("I", "Event done", incommingEvent);
SerialPrint("I", F("Scenario"), "Condition are matched: " + condition);
spaceCmdExecute(oneBlock);
}
}
allBlocks = deleteBeforeDelimiter(allBlocks, "end\n");
}
eventBuf = deleteBeforeDelimiter(eventBuf, ",");
}
private:
bool isScenarioNeedToDo(String &condition, String &incommingEventKey, String &incommingEventValue, int type) {
bool res = false;
String setEventKey = selectFromMarkerToMarker(condition, " ", 0);
if (isEventExist(incommingEventKey, setEventKey)) {
String setEventSign;
String setEventValue;
if (type == 1) preCalculation(condition, setEventSign, setEventValue);
if (type == 2) preCalculationGisteresis(condition, setEventSign, setEventValue);
if (isConditionMatch(setEventSign, incommingEventValue, setEventValue)) {
res = true;
}
}
return res;
}
bool isScenarioNeedToDoJson(String &condition) {
bool res = false;
String setEventKey = selectFromMarkerToMarker(condition, " ", 0);
String setEventSign;
String setEventValue;
preCalculation(condition, setEventSign, setEventValue);
String jsonValue = getValue(setEventKey);
if (isConditionMatch(setEventSign, jsonValue, setEventValue)) {
res = true;
}
return res;
}
//bool isScenarioNeedToDoJson2(String &condition, String &incommingEventKey, String &incommingEventValue) {
// bool res = false;
// String setEventKey = selectFromMarkerToMarker(condition, " ", 0);
// if (isEventExist(incommingEventKey, setEventKey)) {
// String setEventSign;
// String setEventValue;
// preCalculation(condition, setEventSign, setEventValue);
// if (isConditionMatch(setEventSign, incommingEventValue, setEventValue)) {
// res = true;
// }
// }
// return res;
//}
void preCalculation(String &condition, String &setEventSign, String &setEventValue) {
setEventSign = selectFromMarkerToMarker(condition, " ", 1);
setEventValue = selectFromMarkerToMarker(condition, " ", 2);
if (!isDigitDotCommaStr(setEventValue)) {
setEventValue = getValue(setEventValue);
}
}
void preCalculationGisteresis(String &condition, String &setEventSign, String &setEventValue) {
setEventSign = selectFromMarkerToMarker(condition, " ", 1);
setEventValue = selectFromMarkerToMarker(condition, " ", 2);
if (!isDigitDotCommaStr(setEventValue)) {
String setEventValueName = selectToMarker(setEventValue, "+-");
String gisteresisValue = selectToMarkerLast(setEventValue, "+-");
gisteresisValue.replace("+-", "");
String value = getValue(setEventValueName);
String upValue = String(value.toFloat() + gisteresisValue.toFloat());
String lowValue = String(value.toFloat() - gisteresisValue.toFloat());
if (setEventSign == ">") {
setEventValue = upValue;
} else if (setEventSign == "<") {
setEventValue = lowValue;
}
}
}
bool isEventExist(String &incommingEventKey, String &setEventKey) {
bool res = false;
if (incommingEventKey == setEventKey) {
res = true;
}
return res;
}
bool isConditionMatch(String &setEventSign, String &incommingEventValue, String &setEventValue) {
boolean flag = false;
if (setEventSign == "=") {
flag = incommingEventValue == setEventValue;
} else if (setEventSign == "!=") {
flag = incommingEventValue != setEventValue;
} else if (setEventSign == "<") {
flag = incommingEventValue.toFloat() < setEventValue.toFloat();
} else if (setEventSign == ">") {
flag = incommingEventValue.toFloat() > setEventValue.toFloat();
} else if (setEventSign == ">=") {
flag = incommingEventValue.toFloat() >= setEventValue.toFloat();
} else if (setEventSign == "<=") {
flag = incommingEventValue.toFloat() <= setEventValue.toFloat();
}
return flag;
}
};
extern Scenario *myScenario;
extern void streamEventUDP(String event);

107
include/Class/TCircularBuffer.h
View File

@@ -1,107 +0,0 @@
#pragma once
#include <Arduino.h>
template <typename T, size_t BUFFER_SIZE>
class TCircularBuffer {
public:
TCircularBuffer() : _head{0}, _tail{0}, _full{false} {}
~TCircularBuffer() {}
void reset() {
_head = _tail = _full = 0;
}
bool empty() const {
return _head == _tail && !_full;
}
bool full() const {
return _full;
}
/**
* Get the number of elements currently stored in the circular_buffer.
*/
size_t size() const {
size_t res = 0;
if (!_full) {
if (_head < _tail)
res = BUFFER_SIZE + _head - _tail;
else
res = _head - _tail;
} else {
res = BUFFER_SIZE;
}
return res;
}
/** Push the transaction to the buffer. This overwrites the buffer if it's full.
* Загрузить данные в буфер
* @param data item to be pushed to the buffer.
*/
void push(const T &item) {
if (_full) {
_tail++;
if (_tail == BUFFER_SIZE)
_tail = 0;
}
_pool[_head++] = item;
if (_head == BUFFER_SIZE)
_head = 0;
if (_head == _tail)
_full = true;
}
/** Pop from the buffer.
* Забрать данные из буфера
* @param data item to store the data to be popped from the buffer.
* @return True if data popped.
*/
bool pop(T &item) {
bool res = false;
if (!empty()) {
item = _pool[_tail++];
if (_tail == BUFFER_SIZE) _tail = 0;
_full = false;
res = true;
}
return res;
}
bool pop_back(T &item) {
bool res = false;
if (!empty()) {
item = _pool[--_head];
_full = false;
res = true;
}
return res;
}
/** Peek into circular buffer without popping.
*
* @param data item to be peeked from the buffer.
* @return True if the buffer is not empty and data contains a transaction, false otherwise.
*/
bool peek(T &item) const {
bool res = false;
if (!empty()) {
item = _pool[_tail];
res = true;
}
return res;
}
private:
T _pool[BUFFER_SIZE];
size_t _head;
size_t _tail;
bool _full;
};
extern TCircularBuffer<char *, 1024> *myTCircularBuffer;
extern TCircularBuffer<char *, 20480> *myWsBuffer;

178
include/Clock.h
View File

@@ -1,178 +0,0 @@
#pragma once
#include "Clock.h"
#include "Global.h"
#include "Utils/TimeUtils.h"
#include "Utils\SerialPrint.h"
extern void clockInit();
#ifdef ESP8266
#include "sntp.h"
#endif
class Clock {
private:
Time_t _time_local;
Time_t _time_utc;
unsigned long _uptime;
unsigned long _unixtime;
int _timezone;
String _ntp;
bool _hasSynced;
bool _configured;
public:
Clock() : _uptime{0}, _timezone{0}, _ntp{""}, _hasSynced{false}, _configured{false} {};
void loop() {
unsigned long passed = millis_since(_uptime);
if (passed < ONE_SECOND_ms) {
return;
}
_uptime += passed;
// world time
time_t now = getSystemTime();
time_t estimated = _unixtime + (passed / ONE_SECOND_ms);
double drift = difftime(now, estimated);
if (drift > 1) {
// Обработать ситуации c дрифтом времени на значительные величины
}
_unixtime = now;
breakEpochToTime(_unixtime, _time_utc);
breakEpochToTime(_unixtime + getOffsetInSeconds(_timezone), _time_local);
}
bool hasSync() {
if (!_hasSynced) {
startSync();
}
return _hasSynced;
}
void setNtpPool(String ntp) {
if (!_ntp.equals(ntp)) {
_ntp = ntp;
_configured = false;
}
}
void setTimezone(int timezone) {
if (_timezone != timezone) {
_timezone = timezone;
_configured = false;
}
}
void startSync() {
if (!_configured) {
SerialPrint("I", "NTP", "sync to: " + _ntp + " timezone: " + String(_timezone));
setupSntp();
_configured = true;
return;
}
_hasSynced = hasTimeSynced();
if (_hasSynced) {
SerialPrint("I", "NTP", "synced " + getDateDotFormated() + " " + getTime());
} else {
SerialPrint("E", "NTP", F("failed to obtain time"));
}
}
void setupSntp() {
#ifdef ESP8266
sntp_setservername(0, _ntp.c_str());
sntp_setservername(1, "ru.pool.ntp.org");
sntp_setservername(2, "pool.ntp.org");
sntp_stop();
sntp_set_timezone(0);
sntp_init();
#else
configTime(0, 0, _ntp.c_str(), "ru.pool.ntp.org", "pool.ntp.org");
#endif
}
bool hasTimeSynced() const {
return _unixtime > MIN_DATETIME;
}
time_t getSystemTime() const {
timeval tv{0, 0};
timezone tz = timezone{0, 0};
time_t epoch = 0;
if (gettimeofday(&tv, &tz) != -1) {
epoch = tv.tv_sec;
}
return epoch;
}
const String getTimeUnix() {
return String(_unixtime);
}
/*
* Локальное время "дд.ММ.гг"
*/
const String getDateDotFormated() {
char buf[32];
sprintf(buf, "%02d.%02d.%02d", _time_local.day_of_month, _time_local.month, _time_local.year);
return String(buf);
}
/*
* Локальное дата время "дд.ММ.гг чч.мм.cc"
*/
const String getDateTimeDotFormated() {
char buf[32];
sprintf(buf, "%02d.%02d.%02d %02d:%02d:%02d", _time_local.day_of_month, _time_local.month, _time_local.year, _time_local.hour, _time_local.minute, _time_local.second);
return String(buf);
}
/*
* Локальное дата время "дд.ММ.гг чч.мм.cc"
*/
const String getDateTimeDotFormated(Time_t timeNow) {
char buf[32];
sprintf(buf, "%02d.%02d.%02d %02d:%02d:%02d", timeNow.day_of_month, timeNow.month, timeNow.year, timeNow.hour, timeNow.minute, timeNow.second);
return String(buf);
}
/*
* Локальное время "чч:мм:cc"
*/
const String getTime() {
char buf[32];
sprintf(buf, "%02d:%02d:%02d", _time_local.hour, _time_local.minute, _time_local.second);
return String(buf);
}
const String getTimeJson() {
char buf[32];
sprintf(buf, "%02d-%02d-%02d", _time_local.hour, _time_local.minute, _time_local.second);
return String(buf);
}
/*
* Локальное время "чч:мм"
*/
const String getTimeWOsec() {
char buf[32];
sprintf(buf, "%02d:%02d", _time_local.hour, _time_local.minute);
return String(buf);
}
/*
* Время с момента запуска "чч:мм:cc" далее "дд чч:мм"
*/
const String getUptime() {
return prettyMillis(_uptime);
}
};
extern Clock* timeNow;

64
include/Cmd.h
View File

@@ -1,64 +0,0 @@
#pragma once
#include <Arduino.h>
extern void cmd_init();
//extern void levelPr();
//extern void ultrasonicCm();
//extern void ultrasonic_reading();
extern void analog_reading1();
extern void analog_reading2();
extern void dallas_reading();
extern void dhtT_reading();
//extern void dallas();
extern void bmp280T();
extern void bmp280P();
extern void bmp280T_reading();
extern void bmp280P_reading();
extern void bme280T();
extern void bme280P();
extern void bme280H();
extern void bme280A();
extern void bme280T_reading();
extern void bme280P_reading();
extern void bme280H_reading();
extern void bme280A_reading();
//extern void dhtT();
//extern void dhtH();
//extern void dhtP();
//extern void dhtC();
//extern void dhtD();
//extern void dhtH_reading();
//extern void dhtP_reading();
//extern void dhtC_reading();
//extern void dhtD_reading();
extern void timeInit();
extern void stepper();
extern void stepperSet();
extern void servo_();
extern void servoSet();
extern void serialBegin();
extern void serialWrite();
extern void logging();
extern void button();
extern void timeSet();
extern void mqttOrderSend();
extern void httpOrderSend();
extern void firmwareVersion();
extern void firmwareUpdate();
extern void loadScenario();
extern void fileCmdExecute(const String& filename);
extern void csvCmdExecute(String& cmdStr);
extern void spaceCmdExecute(String& cmdStr);

161
include/Consts.h
View File

@@ -1,161 +0,0 @@
#pragma once
#define FIRMWARE_VERSION 400
#define svelte
#ifdef esp8266_4mb
#define FIRMWARE_NAME "esp8266_4mb"
#define USE_LITTLEFS true
#define USE_OTA true
#define LED_PIN 2
#define ESP_MODE
#endif
#ifdef esp8266_1mb
#define FIRMWARE_NAME "esp8266_1mb"
#define USE_LITTLEFS true
#define USE_OTA false
#define LED_PIN 2
#define ESP_MODE
#endif
#ifdef esp32_4mb
#define FIRMWARE_NAME "esp32_4mb"
#define USE_LITTLEFS false
#define USE_OTA true
#define LED_PIN 22
#define ESP_MODE
#endif
#ifdef esp8266_mysensors_4mb
#define FIRMWARE_NAME "esp8266_mysensors_4mb"
#define USE_LITTLEFS true
#define USE_OTA true
#define LED_PIN 2
#define GATE_MODE
#define MYSENSORS
#endif
#ifdef esp32_mysensors_4mb
#define FIRMWARE_NAME "esp32_mysensors_4mb"
#define USE_LITTLEFS false
#define USE_OTA true
#define LED_PIN 22
#define GATE_MODE
#define MYSENSORS
#endif
#define JSON_BUFFER_SIZE 4096
#define NUM_BUTTONS 6
#define MQTT_RECONNECT_INTERVAL 20000
#define CHANGE_BROKER_AFTER 5
#define TELEMETRY_UPDATE_INTERVAL_MIN 60
#define DEVICE_CONFIG_FILE "s.conf.csv"
#define DEVICE_SCENARIO_FILE "s.scen.txt"
//#define OTA_UPDATES_ENABLED
//#define MDNS_ENABLED
#define WEBSOCKET_ENABLED
//#define LAYOUT_IN_RAM
//#define UDP_ENABLED
//#define SSDP_ENABLED
#ifdef ESP_MODE
#define EnableButtonIn
#define EnableButtonOut
#define EnableCountDown
#define EnableImpulsOut
#define EnableInput
#define EnableLogging
#define EnableOutput
#define EnablePwmOut
#define EnableSensorAnalog
#define EnableSensorBme280
#define EnableSensorBmp280
#define EnableSensorCcs811
#define EnableSensorDallas
#define EnableSensorDht
#define EnableSensorPzem
#define EnableSensorUltrasonic
#define EnableSensorUptime
#define EnableTelegram
#define EnableUart
#endif
#ifdef GATE_MODE
#define EnableSensorNode
#define EnableButtonOut
#define EnableCountDown
#define EnableInput
#define EnableLogging
#define EnableOutput
#define EnableSensorUptime
#define EnableTelegram
#define EnableUart
#endif
//================================================================================================================================================================
enum TimerTask_t { WIFI_SCAN,
WIFI_MQTT_CONNECTION_CHECK,
TIME,
TIME_SYNC,
STATISTICS,
UPTIME,
UDP,
SYGNAL,
TIMES,
MYTEST };
enum NotAsyncActions {
do_ZERO,
do_UPGRADE,
do_GETLASTVERSION,
do_BUSSCAN,
do_MQTTPARAMSCHANGED,
do_deviceInit,
do_delChoosingItems,
do_addItem,
do_addPreset,
do_sendScenUDP,
do_sendScenMQTT,
do_webSocketSendSetup,
do_LAST,
};
enum LedStatus_t {
LED_OFF,
LED_ON,
LED_SLOW,
LED_FAST
};
enum ConfigType_t {
CT_CONFIG,
CT_SCENARIO
};
// history
// 07.11.2020 (SSDP OFF, UDP OFF)
// RAM: [===== ] 46.8% (used 38376 bytes from 81920 bytes)
// Flash: [===== ] 54.2% (used 566004 bytes from 1044464 bytes)
// 13.11.2020 (SSDP OFF, UDP OFF)
// RAM: [===== ] 46.6% (used 38208 bytes from 81920 bytes)
// Flash: [===== ] 54.2% (used 566388 bytes from 1044464 bytes)
// 15.11.2020 (SSDP OFF, UDP OFF)
// RAM: [===== ] 46.1% (used 37780 bytes from 81920 bytes)
// Flash: [===== ] 54.3% (used 566656 bytes from 1044464 bytes)
// 17.11.2020 (SSDP OFF, UDP OFF)
// RAM: [===== ] 45.7% (used 37476 bytes from 81920 bytes)
// Flash: [===== ] 54.5% (used 569296 bytes from 1044464 bytes)
// RAM: [===== ] 45.6% (used 37336 bytes from 81920 bytes)
// Flash: [====== ] 55.3% (used 577396 bytes from 1044464 bytes)
// eventBuf - буфер событий которые проверяются в сценариях,
//и если событие удовлетворяет какому нибудь условию то выполняются указанные команды
// orderBuf - буфер команд которые выполняются сейчас же

26
include/ESP32.h
View File

@@ -1,26 +0,0 @@
#pragma once
#ifdef ESP32
// don't change order
#include "WiFi.h"
//
#include "ESPAsyncWebServer.h"
#include "SPIFFSEditor.h"
// don't change order
#include <AsyncUDP.h>
#include <ESP32Servo.h>
#include <HTTPClient.h>
#include <HTTPUpdate.h>
//
#include <WiFi.h>
#ifdef MDNS_ENABLED
#include <ESPmDNS.h>
#endif
extern AsyncUDP udp;
#endif

18
include/ESP8266.h
View File

@@ -1,18 +0,0 @@
#pragma once
#ifdef ESP8266
//#include <ESP8266WebServer.h>
#include <ESP8266httpUpdate.h>
#include "ESPAsyncTCP.h"
#include "ESPAsyncWebServer.h"
#include <SPIFFSEditor.h>
#include <Servo.h>
#include <WiFiUdp.h>
#include <SoftwareSerial.h>
#ifdef MDNS_ENABLED
#include <ESP8266mDNS.h>
#endif
extern WiFiUDP udp;
#endif

29
include/FSEditor.h
View File

@@ -1,29 +0,0 @@
#pragma once
#include <ESPAsyncWebServer.h>
#include "FileSystem.h"
class FSEditor : public AsyncWebHandler {
private:
fs::FS _fs;
String _username;
String _password;
bool _authenticated;
uint32_t _startTime;
private:
void getDirList(const String& path, String& output);
public:
#ifdef ESP32
FSEditor(const fs::FS& fs, const String& username = String(), const String& password = String());
#else
FSEditor(const String& username = String(), const String& password = String(), const fs::FS& fs = FileFS);
#endif
virtual bool canHandle(AsyncWebServerRequest* request) override final;
virtual void handleRequest(AsyncWebServerRequest* request) override final;
virtual void handleUpload(AsyncWebServerRequest* request, const String& filename, size_t index, uint8_t* data, size_t len, bool final) override final;
virtual bool isRequestHandlerTrivial() override final {
return false;
}
};

36
include/FileSystem.h
View File

@@ -1,36 +0,0 @@
#pragma once
#include "Consts.h"
#define FILE_READ "r"
#define FILE_WRITE "w"
#define FILE_APPEND "a"
#include <FS.h>
#ifdef ESP32
#include <SPIFFS.h>
extern FS* filesystem;
#define FileFS SPIFFS
#define FS_NAME "SPIFFS"
#endif
#ifdef ESP8266
#if USE_LITTLEFS
#include "LittleFS.h"
extern FS LittleFS;
using littlefs_impl::LittleFSConfig;
extern FS* filesystem;
#define FileFS LittleFS
#define FS_NAME "LittleFS"
#else
extern FS* filesystem;
#define FileFS SPIFFS
#define FS_NAME "SPIFFS"
#endif
#endif
extern void getFSInfo();
#ifdef ESP8266
extern bool getInfo(FSInfo& info);
#endif

160
include/Global.h
View File

@@ -1,160 +0,0 @@
#pragma once
//===================Libraries===================================================================================================================================================
#include <Arduino.h>
#include <ArduinoJson.h>
#include <ArduinoOTA.h>
#include <PubSubClient.h>
#include <StringCommand.h>
#include <TickerScheduler.h>
#include <Wire.h>
#include <time.h>
#include "CTBot.h"
#include "Clock.h"
#include "Consts.h"
#include "ESP32.h"
#include "ESP8266.h"
#include "GyverFilters.h"
#include "MqttClient.h"
#include "Upgrade.h"
#include "Utils/FileUtils.h"
#include "Utils/JsonUtils.h"
#include "Utils/SerialPrint.h"
#include "Utils/StringUtils.h"
#include "Utils/SysUtils.h"
#include "Utils/WiFiUtils.h"
#ifdef WEBSOCKET_ENABLED
extern AsyncWebSocket ws;
extern AsyncEventSource events;
#endif
extern TickerScheduler ts;
extern WiFiClient espClient;
extern PubSubClient mqtt;
extern StringCommand sCmd;
extern AsyncWebServer server;
// Global vars
extern boolean just_load;
extern boolean telegramInitBeen;
extern boolean savedFromWeb;
extern boolean wsSetupFlag;
// Json
extern String configSetupJson; //все настройки
extern String configLiveJson; //все данные с датчиков (связан с mqtt)
extern String configStoreJson; //все данные которые должны сохраняться
extern String configOptionJson; //для трансфера
extern String telegramMsgJson;
extern String getValue(String& key);
// Mqtt
extern String mqttServer;
extern int mqttPort;
extern String mqttPrefix;
extern String mqttUser;
extern String mqttPass;
extern String mqttRootDevice;
extern String chipId;
extern String prex;
extern String all_widgets;
extern String scenario;
extern int mqttConnectAttempts;
extern bool changeBroker;
extern int currentBroker;
// web sockets
extern int wsAttempts;
//extern char* wsBufChar;
// orders and events
extern String orderBuf;
extern String wsBuf;
extern String eventBuf;
extern String mysensorBuf;
extern String itemsFile;
extern String itemsLine;
// key lists and numbers
//=========================================
extern String impuls_KeyList;
extern int impuls_EnterCounter;
//=========================================
extern String buttonOut_KeyList;
extern int buttonOut_EnterCounter;
//=========================================
extern String input_KeyList;
extern int input_EnterCounter;
//=========================================
extern String output_KeyList;
extern int output_EnterCounter;
//=========================================
extern String pwmOut_KeyList;
extern int pwmOut_EnterCounter;
//=========================================
extern String countDown_KeyList;
extern int countDown_EnterCounter;
//=========================================
extern String logging_KeyList;
extern int logging_EnterCounter;
//=========================================
extern String itemName;
extern String presetName;
extern int scenario_line_status[40];
extern int lastVersion;
// Main
extern void setChipId();
extern void saveConfig();
extern void setConfigParam(const char* param, const String& value);
extern String getURL(const String& urls);
extern void do_fscheck();
extern void doBusScan();
extern void servo_();
extern void setLedStatus(LedStatus_t);
// Scenario
extern void eventGen2(String eventName, String eventValue);
extern String add_set(String param_name);
// Timers
extern void Timer_countdown_init();
extern void timerStart_();
extern void addTimer(String number, String time);
extern void timerStop_();
extern void delTimer(String number);
extern int readTimer(int number);
extern void upgradeInit();
// widget
extern void createWidgetByType(String widget_name, String page_name, String page_number, String file, String topic);
extern void createWidgetParam(String widget_name, String page_name, String page_number, String file, String topic, String name1, String param1, String name2, String param2, String name3, String param3);
extern void createWidget(String widget_name, String page_name, String page_number, String type, String topik);
extern void createChart(String widget_name, String page_name, String page_number, String file, String topic, String maxCount);
// PushingBox
extern void pushControl();
// UDP
// extern void udpInit();
// extern void do_udp_data_parse();
// extern void do_mqtt_send_settings_to_udp();
extern void do_update();
// Init
extern void uptime_init();
// Web
extern void web_init();
// Upgrade
extern String serverIP;

11
include/Init.h
View File

@@ -1,11 +0,0 @@
#pragma once
extern void loadConfig();
extern void espInit();
extern void statistics_init();
extern void loadScenario();
extern void deviceInit();
extern void prsets_init();
extern void handle_uptime();
extern void handle_statistics();
extern void clearVectors();

19
include/ItemsList.h
View File

@@ -1,19 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Global.h"
extern void itemsListInit();
extern void addItem2(int num);
extern void addItemAuto(int num, String key, String widget, String descr);
extern bool isItemAdded(String key);
extern void addPreset(String name);
extern void addPreset2(int num);
extern void delChoosingItems();
extern void addPreset2(int num);
extern void delChoosingItemsByNum(int num);
extern void delAllItems();
extern uint8_t getNewElementNumber(String file);
extern uint8_t getFreePinAll();
extern bool isPinExist(unsigned int num);
extern uint8_t getFreePinAnalog();

9
include/Macro.h
View File

@@ -1,9 +0,0 @@
//#pragma once
//#define ST(A) #A
//#define STR(A) ST(A)
//
//#ifdef esp32_4mb
//#pragma message STR(esp32_4mb)
//#endif
//Serial.println(STR(esp32_4mb));

29
include/MqttClient.h
View File

@@ -1,29 +0,0 @@
#pragma once
#include <Arduino.h>
void mqttInit();
void selectBroker();
void getMqttData1();
void getMqttData2();
bool isSecondBrokerSet();
boolean mqttConnect();
void mqttReconnect();
void mqttLoop();
void mqttSubscribe();
boolean publish(const String& topic, const String& data);
boolean publishData(const String& topic, const String& data);
boolean publishChart(const String& topic, const String& data);
boolean publishControl(String id, String topic, String state);
boolean publishChart_test(const String& topic, const String& data);
boolean publishStatus(const String& topic, const String& data);
boolean publishEvent(const String& topic, const String& data);
boolean publishInfo(const String& topic, const String& data);
boolean publishAnyJsonKey(const String& topic, const String& key, const String& data);
void publishWidgets();
void publishState();
void mqttCallback(char* topic, uint8_t* payload, size_t length);
const String getStateStr();

8
include/MqttDiscovery.h
View File

@@ -1,8 +0,0 @@
#pragma once
#include "Utils/SysUtils.h"
namespace Discovery {
}

8
include/MySensorsDataParse.h
View File

@@ -1,8 +0,0 @@
#include "Consts.h"
#ifdef MYSENSORS
#pragma once
#include "Global.h"
extern void loopMySensorsExecute();
extern void sensorType(int index, int &num, String &widget, String &descr);
extern void test(char* inputString);
#endif

14
include/MySensorsDataRead.h
View File

@@ -1,14 +0,0 @@
#include "Consts.h"
#include "Global.h"
#ifdef MYSENSORS
//#define MY_DEBUG
#define MY_RADIO_RF24
#define MY_RF24_PA_LEVEL RF24_PA_HIGH //RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX
//#define MY_ENCRYPTION_SIMPLE_PASSWD "XpenBam"
//#define MY_RF24_DATARATE RF24_2MBPS
#define MY_GATEWAY_SERIAL
#include "MySensors.h"
extern void receive(const MyMessage &message);
extern String parseToString(const MyMessage &message);
#endif

9
include/RemoteOrdersUdp.h
View File

@@ -1,9 +0,0 @@
#pragma once
#ifdef ESP8266
#include "ESPAsyncUDP.h"
extern AsyncUDP asyncUdp;
extern void asyncUdpInit();
extern String uint8tToString(uint8_t* data, size_t len);
extern bool udpPacketValidation(String& data);
extern void udpPacketParse(String& data);
#endif

9
include/SSDP.h
View File

@@ -1,9 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Consts.h"
#ifdef SSDP_ENABLED
void SsdpInit();
#endif

3
include/Sensors.h
View File

@@ -1,3 +0,0 @@
#pragma once

29
include/Servo/Servos.h
View File

@@ -1,29 +0,0 @@
#pragma once
#include <Arduino.h>
#ifdef ESP8266
#include <Servo.h>
#else
#include <ESP32Servo.h>
#endif
struct Servo_t {
uint8_t num;
uint8_t pin;
Servo* obj;
Servo_t(uint8_t num, uint8_t pin) : num{num}, pin{pin}, obj{nullptr} {};
};
class Servos {
public:
Servos();
Servo* get(uint8_t num);
Servo* create(uint8_t num, uint8_t pin);
size_t count();
private:
std::vector<Servo_t> _items;
};
extern Servos myServo;

12
include/SetupESP.h
View File

@@ -1,12 +0,0 @@
#pragma once
#include <Arduino.h>
#include <ArduinoJson.h>
#include <FS.h>
#include <StreamUtils.h>
#include "LittleFS.h"
#include "Utils/FileUtils.h"
#include "Utils/StringUtils.h"
extern void setupESP();

18
include/SoftUART.h
View File

@@ -1,18 +0,0 @@
#pragma once
#include "Consts.h"
#ifdef EnableUart
#include "SoftwareSerial.h"
#ifdef ESP8266
#include <SoftwareSerial.h>
extern SoftwareSerial* myUART;
#else
#include <HardwareSerial.h>
extern HardwareSerial* myUART;
#endif
extern void uartInit();
extern void uartHandle();
extern void parse(String& incStr);
#endif

139
include/Strings_.h
View File

@@ -1,139 +0,0 @@
#pragma once
//Strings
// #include <stdafx.h>
#include <stdio.h>
#include <cstring>
#include <iostream>
class char_array {
private:
char *p_stringarray; //initial input array
char *p_inputstring; //holds actual length data
//char **pp_database_string; //allocate data database.cpp
int stringsize; //holds array size to allocate memory
int charinput; //holds array input size
public:
inline char_array(); //inline so other functions can call on it
inline ~char_array();
inline void getinput(char *&); //retrieves user input
inline void grabline(char *&); //retrieve line with whitespace included NOT COMPLETE, may not need
inline int sortline(char **&, char *&); //sorts line into an array of strings and returns number of separate strings
inline int arraysize(); //returns size of string array
inline void printinput(); //print input string
inline void changedefaultsize(); //change default input size NOT COMPLETE
};
inline char_array::char_array() //constructor
{
stringsize = 0;
charinput = 64;
p_stringarray = new char[charinput];
}
inline char_array::~char_array() //destructor
{
delete[] p_inputstring;
delete[] p_stringarray;
}
inline void char_array::getinput(char *&p_stringin) {
stringsize = 0;
scanf("%63s", p_stringarray); //get input string
while (p_stringarray[stringsize] != 0) //finding out the size of string array
{
stringsize++;
}
stringsize++;
p_inputstring = new char[stringsize]; //reallocate memory block and set array inside
for (int i = 0; i < stringsize; i++) {
p_inputstring[i] = p_stringarray[i];
}
p_inputstring[stringsize - 1] = '\x00';
p_stringin = new char[stringsize]; //set pp_stringin
p_stringin = p_inputstring;
}
inline void char_array::grabline(char *&p_stringin) {
stringsize = 0;
std::cin.getline(p_stringarray, charinput);
while (p_stringarray[stringsize] != 0) {
stringsize++;
}
stringsize++;
p_inputstring = new char[stringsize];
for (int i = 0; i < stringsize; i++) {
p_inputstring[i] = p_stringarray[i];
}
p_stringin = new char[stringsize];
p_stringin = p_inputstring;
}
inline int char_array::sortline(char **&pp_stringin, char *&p_string) {
int position = 0; //position in string
int charcount = 1; //how many characters there are
int wordnum; //which word is being processed
int wordcount = 1; //number of words in string
int bookmark = 0; //holds last known position
while (p_string[position] == ' ') {
position++;
}
wordnum = position; //borrow wordnum to hold position value
while (p_string[position] != '\x00') //find total inputted string word length
{
if ((p_string[position] == ' ') && ((p_string[position + 1] != ' ') || (p_string[position + 1] != '\x00'))) {
wordcount++;
}
position++;
}
position = wordnum; //set position to original value
for (wordnum = 0; wordnum < wordcount; wordnum++) {
charcount = 1;
while (p_string[position] == ' ') {
position++;
}
while ((p_string[position] != ' ') && (p_string[position] != '\x00')) {
position++;
charcount++;
}
pp_stringin[wordnum] = new char[charcount];
for (int i = 0; i < charcount; i++) {
pp_stringin[wordnum][i] = p_string[i + bookmark];
}
pp_stringin[wordnum][charcount - 1] = '\x00';
bookmark = position + 1;
}
return wordcount;
}
inline int char_array::arraysize() {
if (stringsize != 0) {
return stringsize;
} else {
printf("Array size is set at 0\n");
return 0;
}
}
inline void char_array::printinput() {
printf("%s", p_inputstring);
}
inline void char_array::changedefaultsize() {
printf("Input new default input string size: ");
scanf("%i", charinput);
}

13
include/Telegram.h
View File

@@ -1,13 +0,0 @@
#pragma once
#include "Consts.h"
#ifdef EnableTelegram
#include "Global.h"
extern void sendTelegramMsg();
extern void telegramInit();
extern void handleTelegram();
extern bool isEnableTelegramd();
extern bool isTelegramInputOn();
extern void telegramMsgParse(String msg);
extern String returnListOfParams();
#endif

4
include/Tests.h
View File

@@ -1,4 +0,0 @@
#pragma once
extern void testsPerform();
extern void testLoop();

10
include/Upgrade.h
View File

@@ -1,10 +0,0 @@
#pragma once
#include <Arduino.h>
extern void upgradeInit();
extern void getLastVersion();
extern void upgrade_firmware(int type);
extern bool upgradeFS();
extern bool upgradeBuild();
extern void restartEsp();

46
include/Utils/FileHelper.h
View File

@@ -1,46 +0,0 @@
#pragma once
#include <Arduino.h>
#include "FileSystem.h"
class FileHelper {
public:
FileHelper(const String filename);
/*
* Проверить существование
*/
void exists();
/*
* Удалить файл
*/
void remove();
/*
* Открыть файл установить позицию @position
*/
File seek(size_t position = 0);
/*
* Чтение строки с содержащей @substr
*/
String readFileString(const String substr);
/*
* Добовление строки @str в файл
*/
String appendStr(const String str);
/*
* Запись строки
*/
String writeStr(const String);
/*
* Чтение в строку
*/
String readStr(size_t);
/*
* Размер в байтах
*/
size_t getSize();
};

64
include/Utils/FileUtils.h
View File

@@ -1,64 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Consts.h"
#include "FileSystem.h"
/*
* Инициализация ФС
*/
bool fileSystemInit();
/*
* Удалить файл
*/
void removeFile(const String& filename);
/*
* Открыть файл на позиции
*/
File seekFile(const String& filename, size_t position = 0);
/*
* Чтение строки из файла
* возвращает стоку из файла в которой есть искомое слово found
*/
const String readFileString(const String& filename, const String& to_find);
/*
* Добовление строки в файл
*/
const String addFileLn(const String& filename, const String& str);
/*
* Добовление строки в файл
*/
const String addFile(const String& filename, const String& str);
/*
* Запись строки в файл
*/
const String writeFile(const String& filename, const String& str);
/*
* Чтение файла в строку
*/
const String readFile(const String& filename, size_t max_size);
/*
* Посчитать
*/
size_t countLines(const String filename);
/*
* Размер файла
*/
size_t getFileSize(const String filename);
bool copyFile(const String& src, const String& dst, bool overwrite = true);
const String getFSSizeInfo();
const String getConfigFile(uint8_t preset, ConfigType_t type);
bool cutFile(const String& src, const String& dst);

24
include/Utils/JsonUtils.h
View File

@@ -1,24 +0,0 @@
#pragma once
#include <Arduino.h>
String jsonReadStr(String& json, String name);
int jsonReadInt(String& json, String name);
boolean jsonReadBool(String& json, String name);
String jsonWriteStr(String& json, String name, String value);
String jsonWriteInt(String& json, String name, int value);
String jsonWriteFloat(String& json, String name, float value);
String jsonWriteBool(String& json, String name, boolean value);
bool jsonRead(String& json, String key, String& value);
bool jsonRead(String& json, String key, bool& value);
bool jsonRead(String& json, String key, int& value);
bool jsonWriteStr_(String& json, String name, String value);
bool jsonWriteBool_(String& json, String name, bool value);
bool jsonWriteInt_(String& json, String name, int value);
bool jsonWriteFloat_(String& json, String name, float value);
void saveConfig();
void saveStore();

3
include/Utils/SerialPrint.h
View File

@@ -1,3 +0,0 @@
#pragma once
#include <Arduino.h>
void SerialPrint(String errorLevel, String module, String msg);

36
include/Utils/StringUtils.h
View File

@@ -1,36 +0,0 @@
#pragma once
#include <Arduino.h>
uint8_t hexStringToUint8(String hex);
uint16_t hexStringToUint16(String hex);
String selectToMarkerLast(String str, String found);
String selectToMarker(String str, String found);
String extractInner(String str);
String deleteAfterDelimiter(String str, String found);
String deleteBeforeDelimiter(String str, String found);
String deleteBeforeDelimiterTo(String str, String found);
String deleteToMarkerLast(String str, String found);
String selectFromMarkerToMarker(String str, String found, int number);
size_t itemsCount2(String str, const String& separator);
char* stringToChar(String& str);
size_t itemsCount(String& str, const char* delim);
boolean isDigitStr(const String& str);
boolean isDigitDotCommaStr(const String& str);
String prettyBytes(size_t size);

19
include/Utils/SysUtils.h
View File

@@ -1,19 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Global.h"
uint32_t ESP_getChipId();
const String getChipId();
void setLedStatus(LedStatus_t status);
const String getUniqueId(const String& name);
const String printMemoryStatus();
const String getHeapStats();
const String getMacAddress();
void setChipId();

69
include/Utils/TimeUtils.h
View File

@@ -1,69 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Consts.h"
#define ONE_MINUTE_s 60
#define ONE_HOUR_m 60
#define ONE_HOUR_s 60 * ONE_MINUTE_s
#define LEAP_YEAR(Y) (((1970 + Y) > 0) && !((1970 + Y) % 4) && (((1970 + Y) % 100) || !((1970 + Y) % 400)))
#define MIN_DATETIME 1575158400
#define ONE_SECOND_ms 1000
/*
* Время (мс) прошедщее с @since
*/
unsigned long millis_since(unsigned long sinse);
/*
* Интерввал времени (мс) между @start и @finish
*/
unsigned long millis_passed(unsigned long start, unsigned long finish);
/*
* Форматиронное время интервала (мс)
* "чч:мм:cc",
* "дд чч:мм", если > 24 часов
*/
const String prettyMillis(unsigned long time_ms = millis());
/*
* Форматиронное время интервала (c)
* "чч:мм:cc",
* "дд чч:мм", если > 24 часов
*/
const String prettySeconds(unsigned long time_s);
/*
* Тайм зона в секундах
*/
int getOffsetInSeconds(int timezone);
/*
* Тайм зона в минутах
*/
int getOffsetInMinutes(int timezone);
/*
* Разбивает время на составляющие
*/
struct Time_t {
uint8_t second;
uint8_t minute;
uint8_t hour;
uint8_t day_of_week;
uint8_t day_of_month;
uint8_t month;
uint16_t day_of_year;
uint16_t year;
unsigned long days;
unsigned long valid;
};
void breakEpochToTime(unsigned long epoch, Time_t& tm);
void timeInit();

71
include/Utils/Timings.h
View File

@@ -1,71 +0,0 @@
#include <Arduino.h>
enum Timings_t { MT_ONE,
MT_TWO,
NUM_TIMINGS };
struct Timing {
unsigned long _total_mu;
unsigned long _min_mu;
unsigned long _max_mu;
Timing() : _total_mu{0}, _min_mu{999999}, _max_mu{0} {};
void reset() {
_total_mu = 0;
_min_mu = 999999;
_max_mu = 0;
}
void add(unsigned long time_mu) {
if (time_mu == 0) return;
_total_mu += time_mu;
if (_min_mu > time_mu) {
_min_mu = time_mu;
}
if (_max_mu < time_mu) {
_max_mu = time_mu;
}
}
};
static const char* module_name[NUM_TIMINGS] = {"strings", "boolean"};
struct Timings {
Timing mu[NUM_TIMINGS];
unsigned long _counter;
unsigned long _start;
unsigned long long _total;
Timings() : _counter{0}, _start{0} {};
void add(size_t module, unsigned long now = micros()) {
unsigned long time = now - _start;
_total += time;
mu[module].add(time);
_start = now;
}
void count() {
_counter++;
_start = micros();
}
void print() {
if (!_counter) {
return;
};
Serial.printf("lp/ms: %llu ", _counter / _total);
for (size_t i = 0; i < NUM_TIMINGS; i++) {
Serial.printf("%s: %.2f%% ", module_name[i], ((float)mu[i]._total_mu / _total) * 100);
mu[i].reset();
}
Serial.println();
_counter = 0;
_total = 0;
};
};

8
include/Utils/WebUtils.h
View File

@@ -1,8 +0,0 @@
#pragma once
#include <Arduino.h>
#include "WebServer.h"
extern String getURL(const String& urls);
extern const String getMethodName(AsyncWebServerRequest* request);
extern const String getRequestInfo(AsyncWebServerRequest* request);

16
include/Utils/WiFiUtils.h
View File

@@ -1,16 +0,0 @@
#pragma once
#include "Global.h"
boolean isNetworkActive();
void routerConnect();
bool startAPMode();
boolean RouterFind(String ssid);
uint8_t RSSIquality();
extern void wifiSignalInit();

22
include/Utils/statUtils.h
View File

@@ -1,22 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Global.h"
extern void initSt();
extern String updateDevicePsn(String lat, String lon, String accur, String geo);
extern String updateDeviceStatus();
extern String addNewDevice();
extern void decide();
extern void getPsn();
extern String getUptimeTotal();
extern uint8_t getNextNumber(String file);
extern uint8_t getCurrentNumber(String file);
//extern int plusOneHour();
//extern void eeWriteInt(int pos, int val);
//extern int eeGetInt(int pos);
//extern void updateDeviceList();
//extern void saveId(String file, int id);
//extern int getId(String file);

6
include/Web.h
View File

@@ -1,6 +0,0 @@
#pragma once
#include "Arduino.h"
void web_init();
void setConfigParam(const char* param, const String& value);

12
include/WebServer.h
View File

@@ -1,12 +0,0 @@
#pragma once
#include "Global.h"
extern void initOta();
extern void initMDNS();
extern void HttpServerinitWS();
extern void HttpServerinit();
//===========web sockets==============================
extern void sendEspSetupToWS();

11
include/WebSocket.h
View File

@@ -1,11 +0,0 @@
#pragma once
#include "Class/TCircularBuffer.h"
#include "Global.h"
void wsInit();
void wsPublishData(String topic, String data);
// void wsSendSetup();
// void wsSendSetupBuffer();
//
// void sendDataWs();
// void loopWsExecute();

65
include/items/ButtonInClass.h
View File

@@ -1,65 +0,0 @@
#ifdef EnableButtonIn
#pragma once
#include <Arduino.h>
#include <Bounce2.h>
#include "Class/LineParsing.h"
#include "Global.h"
extern boolean but[NUM_BUTTONS];
extern Bounce* buttons;
class ButtonInClass : public LineParsing {
protected:
int numberEntering = 0;
int state = _state.toInt();
public:
ButtonInClass() : LineParsing(){};
void init() {
if (_pin != "") {
int number = numberEntering++;
buttons[number].attach(_pin.toInt());
buttons[number].interval(_db.toInt());
but[number] = true;
jsonWriteStr(configOptionJson, "switch_num_" + String(number), _key);
}
}
void loop() {
static uint8_t switch_number = 1;
if (but[switch_number]) {
buttons[switch_number].update();
if (buttons[switch_number].fell()) {
String key = jsonReadStr(configOptionJson, "switch_num_" + String(switch_number));
state = 1;
switchChangeVirtual(key, String(state));
}
if (buttons[switch_number].rose()) {
String key = jsonReadStr(configOptionJson, "switch_num_" + String(switch_number));
state = 0;
switchChangeVirtual(key, String(state));
}
}
switch_number++;
if (switch_number == NUM_BUTTONS) {
switch_number = 0;
}
}
void switchStateSetDefault() {
if (_state != "") {
switchChangeVirtual(_key, _state);
}
}
void switchChangeVirtual(String key, String state) {
eventGen2(key, state);
jsonWriteInt(configLiveJson, key, state.toInt());
publishStatus(key, state);
}
};
extern ButtonInClass myButtonIn;
#endif

34
include/items/test.h
View File

@@ -1,34 +0,0 @@
//#include "Arduino.h"
//#include "Global.h"
//
//class SensorImpulsIn;
//
//typedef std::vector<SensorImpulsIn> MySensorImpulsInVector;
//
//struct paramsImpulsIn {
// String key;
// unsigned int pin;
// float c;
// float k;
//};
//
//class SensorImpulsIn {
// public:
// SensorImpulsIn(const paramsImpulsIn& paramsImpuls);
// //~SensorImpulsIn();
//
// //void begin(int interruptPin);
// void classInterruptHandler(void);
//
// void setCallback(void (*userDefinedCallback)(const int)) {
// localPointerToCallback = userDefinedCallback;
// }
//
// private:
// void (*localPointerToCallback)(const int);
// paramsImpulsIn _paramsImpuls;
//};
//
//extern MySensorImpulsInVector* mySensorImpulsIn;
//
//extern void impulsInSensor();

30
include/items/vButtonOut.h
View File

@@ -1,30 +0,0 @@
#ifdef EnableButtonOut
#pragma once
#include <Arduino.h>
#include "Global.h"
class ButtonOut;
typedef std::vector<ButtonOut> MyButtonOutVector;
class ButtonOut {
public:
ButtonOut(String pin, boolean inv, String key, String type);
~ButtonOut();
void execute(String state);
private:
String _pin;
boolean _inv;
String _key;
String _type;
};
extern MyButtonOutVector* myButtonOut;
extern void buttonOut();
extern void buttonOutExecute();
#endif

34
include/items/vCountDown.h
View File

@@ -1,34 +0,0 @@
#ifdef EnableCountDown
#pragma once
#include <Arduino.h>
#include "Global.h"
class CountDownClass;
typedef std::vector<CountDownClass> MyCountDownVector;
class CountDownClass {
public:
CountDownClass(String key);
~CountDownClass();
void loop();
void execute(unsigned int countDownPeriod);
private:
unsigned long _countDownPeriod = 0;
bool _start = false;
String _key;
unsigned long prevMillis;
unsigned long difference;
int sec;
};
extern MyCountDownVector* myCountDown;
extern void countDown();
extern void countDownExecute();
#endif

33
include/items/vImpulsOut.h
View File

@@ -1,33 +0,0 @@
#ifdef EnableImpulsOut
#pragma once
#include <Arduino.h>
#include "Global.h"
class ImpulsOutClass;
typedef std::vector<ImpulsOutClass> MyImpulsOutVector;
class ImpulsOutClass {
public:
ImpulsOutClass(unsigned int impulsPin);
~ImpulsOutClass();
void loop();
void execute(unsigned long impulsPeriod, unsigned int impulsCount);
private:
unsigned long currentMillis;
unsigned long prevMillis;
unsigned long difference;
unsigned long _impulsPeriod = 0;
unsigned int _impulsCount = 0;
unsigned int _impulsCountBuf = 0;
unsigned int _impulsPin = 0;
};
extern MyImpulsOutVector* myImpulsOut;
extern void impuls();
extern void impulsExecute();
#endif

27
include/items/vInput.h
View File

@@ -1,27 +0,0 @@
#ifdef EnableInput
#pragma once
#include <Arduino.h>
#include "Consts.h"
#include "Global.h"
class Input;
typedef std::vector<Input> MyInputVector;
class Input {
public:
Input(String key, String widget);
~Input();
void execute(String value);
private:
String _key;
};
extern MyInputVector* myInput;
extern void inputValue();
extern void inputExecute();
#endif

44
include/items/vLogging.h
View File

@@ -1,44 +0,0 @@
#ifdef EnableLogging
#pragma once
#include "Consts.h"
#include <Arduino.h>
#include "Global.h"
class LoggingClass;
typedef std::vector<LoggingClass> MyLoggingVector;
class LoggingClass {
public:
LoggingClass(String interval, unsigned int maxPoints, String loggingValueKey, String key, String startState, bool savedFromWeb);
~LoggingClass();
void loop();
void execute(String keyOrValue);
private:
unsigned long currentMillis;
unsigned long prevMillis;
unsigned long difference;
String _interval;
unsigned int _intervalSec;
unsigned int _type = 0;
unsigned int _maxPoints;
String _loggingValueKey;
String _key;
};
extern MyLoggingVector* myLogging;
extern void logging();
extern void loggingExecute();
extern void choose_log_date_and_send();
extern void sendLogData(String file, String topic);
extern void sendLogData2(String file, String topic);
extern void cleanLogAndData();
#endif

30
include/items/vOutput.h
View File

@@ -1,30 +0,0 @@
#ifdef EnableOutput
#pragma once
#include <Arduino.h>
#include "Global.h"
class Output;
typedef std::vector<Output> MyOutputVector;
class Output {
public:
Output(String key);
~Output();
void execute(String value);
private:
String _key;
};
extern MyOutputVector* myOutput;
extern void outputValue();
extern void outputExecute();
#endif

28
include/items/vPwmOut.h
View File

@@ -1,28 +0,0 @@
#ifdef EnablePwmOut
#pragma once
#include <Arduino.h>
#include "Consts.h"
#include "Global.h"
class PwmOut;
typedef std::vector<PwmOut> MyPwmOutVector;
class PwmOut {
public:
PwmOut(unsigned int pin, String key);
~PwmOut();
void execute(String state);
private:
unsigned int _pin;
String _key;
};
extern MyPwmOutVector* myPwmOut;
extern void pwmOut();
extern void pwmOutExecute();
#endif

41
include/items/vSensorAnalog.h
View File

@@ -1,41 +0,0 @@
#ifdef EnableSensorAnalog
#pragma once
#include <Arduino.h>
#include "Global.h"
#include "GyverFilters.h"
class SensorAnalog;
typedef std::vector<SensorAnalog> MySensorAnalogVector;
class SensorAnalog {
public:
SensorAnalog(String key, unsigned long interval, unsigned int adcPin, int map1, int map2, int map3, int map4, float c);
~SensorAnalog();
void loop();
void readAnalog();
private:
unsigned long currentMillis;
unsigned long prevMillis;
unsigned long difference;
unsigned long _interval;
String _key;
unsigned int _adcPin;
int _map1;
int _map2;
int _map3;
int _map4;
float _c;
};
extern MySensorAnalogVector* mySensorAnalog;
extern void analogAdc();
#endif

41
include/items/vSensorBme280.h
View File

@@ -1,41 +0,0 @@
#ifdef EnableSensorBme280
#pragma once
#include <Adafruit_BME280.h>
#include <Arduino.h>
#include "Global.h"
extern Adafruit_BME280* bme;
class SensorBme280;
typedef std::vector<SensorBme280> MySensorBme280Vector;
struct paramsBme {
String key;
String addr;
unsigned long interval;
float c;
};
class SensorBme280 {
public:
SensorBme280(const paramsBme& paramsTmp, const paramsBme& paramsHum, const paramsBme& paramsPrs);
~SensorBme280();
void loop();
void read();
private:
paramsBme _paramsTmp;
paramsBme _paramsHum;
paramsBme _paramsPrs;
unsigned long prevMillis;
unsigned long difference;
};
extern MySensorBme280Vector* mySensorBme280;
extern void bme280Sensor();
#endif

40
include/items/vSensorBmp280.h
View File

@@ -1,40 +0,0 @@
#ifdef EnableSensorBmp280
#pragma once
#include <Adafruit_BMP280.h>
#include <Arduino.h>
#include "Global.h"
extern Adafruit_BMP280* bmp;
class SensorBmp280;
typedef std::vector<SensorBmp280> MySensorBmp280Vector;
struct paramsBmp {
String key;
String addr;
unsigned long interval;
float c;
};
class SensorBmp280 {
public:
SensorBmp280(const paramsBmp& paramsTmp, const paramsBmp& paramsPrs);
~SensorBmp280();
void loop();
void read();
private:
paramsBmp _paramsTmp;
paramsBmp _paramsPrs;
unsigned long prevMillis;
unsigned long difference;
};
extern MySensorBmp280Vector* mySensorBmp280;
extern void bmp280Sensor();
#endif

41
include/items/vSensorCcs811.h
View File

@@ -1,41 +0,0 @@
#ifdef EnableSensorCcs811
#pragma once
#include <Arduino.h>
#include "Adafruit_CCS811.h"
#include "Global.h"
#include "GyverFilters.h"
class SensorCcs811;
typedef std::vector<SensorCcs811> MySensorCcs811Vector;
struct paramsCcs811 {
String key;
String addr;
unsigned long interval;
float c;
};
class SensorCcs811 {
public:
SensorCcs811(const paramsCcs811& paramsPpm, const paramsCcs811& paramsPpb);
~SensorCcs811();
Adafruit_CCS811* ccs811;
void loop();
void read();
private:
paramsCcs811 _paramsPpm;
paramsCcs811 _paramsPpb;
unsigned long prevMillis;
unsigned long difference;
};
extern MySensorCcs811Vector* mySensorCcs811;
extern void ccs811Sensor();
#endif

37
include/items/vSensorDallas.h
View File

@@ -1,37 +0,0 @@
#ifdef EnableSensorDallas
#pragma once
#include <Arduino.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include "Global.h"
extern DallasTemperature sensors;
extern OneWire* oneWire;
class SensorDallas;
typedef std::vector<SensorDallas> MySensorDallasVector;
class SensorDallas {
public:
SensorDallas(unsigned long interval, unsigned int pin, unsigned int index, String key);
~SensorDallas();
void loop();
void readDallas();
private:
unsigned long currentMillis;
unsigned long prevMillis;
unsigned long difference;
unsigned long _interval;
String _key;
unsigned int _pin;
unsigned int _index;
};
extern MySensorDallasVector* mySensorDallas2;
extern void dallas();
#endif

42
include/items/vSensorDht.h
View File

@@ -1,42 +0,0 @@
#ifdef EnableSensorDht
#pragma once
#include <Arduino.h>
#include <DHTesp.h>
#include "Global.h"
#include "GyverFilters.h"
class SensorDht;
typedef std::vector<SensorDht> MySensorDhtVector;
struct paramsDht {
String type;
String key;
unsigned long interval;
unsigned int pin;
float c;
};
class SensorDht {
public:
SensorDht(const paramsDht& paramsTmp, const paramsDht& paramsHum);
~SensorDht();
DHTesp* dht;
void loop();
void readTmpHum();
private:
paramsDht _paramsTmp;
paramsDht _paramsHum;
unsigned long prevMillis;
unsigned long difference;
};
extern MySensorDhtVector* mySensorDht;
extern void dhtSensor();
#endif

32
include/items/vSensorImpulsIn.h
View File

@@ -1,32 +0,0 @@
//#pragma once
//#include <Arduino.h>
//
//#include "Global.h"
//#include "PZEMSensor.h"
//#include "SoftUART.h"
//
//class SensorImpulsIn;
//
//typedef std::vector<SensorImpulsIn> MySensorImpulsInVector;
//
//struct paramsImpulsIn {
// String key;
// unsigned int pin;
// float c;
// float k;
//};
//
//class SensorImpulsIn {
// public:
// SensorImpulsIn(const paramsImpulsIn& paramsImpuls);
// ~SensorImpulsIn();
//
// void interruptHandler(void);
//
// private:
// paramsImpulsIn _paramsImpuls;
//};
//
//extern MySensorImpulsInVector* mySensorImpulsIn;
//
//extern void impulsInSensor();

41
include/items/vSensorNode.h
View File

@@ -1,41 +0,0 @@
#ifdef EnableSensorNode
#pragma once
#include <Arduino.h>
#include "Global.h"
class SensorNode;
typedef std::vector<SensorNode> MySensorNodeVector;
struct paramsSensorNode {
String tm1;
String tm2;
String key;
float c;
float k;
};
class SensorNode {
public:
SensorNode(const paramsSensorNode& params);
~SensorNode();
void loop();
void onChange(String newValue, String incommingKey);
void publish();
private:
paramsSensorNode _params;
long _minutesPassed;
String _updateTime;
unsigned long prevMillis;
unsigned long difference;
};
extern MySensorNodeVector* mySensorNode;
extern void nodeSensor();
extern void publishTimes();
#endif

46
include/items/vSensorPzem.h
View File

@@ -1,46 +0,0 @@
#ifdef EnableSensorPzem
#pragma once
#include <Arduino.h>
#include "Global.h"
#include "PZEMSensor.h"
#include "SoftUART.h"
class SensorPzem;
typedef std::vector<SensorPzem> MySensorPzemVector;
struct paramsPzem {
String key;
String addr;
unsigned long interval;
float c;
float k;
};
class SensorPzem {
public:
SensorPzem(const paramsPzem& paramsV, const paramsPzem& paramsA, const paramsPzem& paramsWatt, const paramsPzem& paramsWattHrs, const paramsPzem& paramsHz);
~SensorPzem();
void loop();
private:
void read();
paramsPzem _paramsV;
paramsPzem _paramsA;
paramsPzem _paramsWatt;
paramsPzem _paramsWattHrs;
paramsPzem _paramsHz;
PZEMSensor* pzem;
unsigned long prevMillis;
unsigned long difference;
};
extern MySensorPzemVector* mySensorPzem;
extern void pzemSensor();
#endif

42
include/items/vSensorUltrasonic.h
View File

@@ -1,42 +0,0 @@
#ifdef EnableSensorUltrasonic
#pragma once
#include <Arduino.h>
#include "Global.h"
#include "GyverFilters.h"
class SensorUltrasonic;
typedef std::vector<SensorUltrasonic> MySensorUltrasonicVector;
class SensorUltrasonic {
public:
SensorUltrasonic(String key, unsigned long interval, unsigned int trig, unsigned int echo, int map1, int map2, int map3, int map4, float c);
~SensorUltrasonic();
void loop();
void readUltrasonic();
private:
unsigned long currentMillis;
unsigned long prevMillis;
unsigned long difference;
unsigned long _interval;
String _key;
unsigned int _echo;
unsigned int _trig;
int _map1;
int _map2;
int _map3;
int _map4;
float _c;
};
extern MySensorUltrasonicVector* mySensorUltrasonic;
extern void ultrasonic();
#endif

35
include/items/vSensorUptime.h
View File

@@ -1,35 +0,0 @@
#ifdef EnableSensorUptime
#pragma once
#include <Arduino.h>
#include "Global.h"
#include "GyverFilters.h"
class SensorUptime;
typedef std::vector<SensorUptime> MySensorUptimeVector;
struct paramsUptime {
String key;
unsigned long interval;
};
class SensorUptime {
public:
SensorUptime(const paramsUptime& paramsUpt);
~SensorUptime();
void loop();
void read();
private:
paramsUptime _paramsUpt;
unsigned long prevMillis;
unsigned long difference;
};
extern MySensorUptimeVector* mySensorUptime;
extern void uptimeSensor();
#endif