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

delete

Browse Source
This commit is contained in:
Dmitry Borisenko
2021-10-05 19:19:14 +08:00
parent 60a292a2f5
commit 74c31e30ea
269 changed files with 0 additions and 20922 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
include/BufferExecute.h
View File

@@ -1,19 +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;

261
include/Class/LineParsing.h
View File

@@ -1,261 +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 _inv;
String _state;
String _db;
String _type;
String _int;
String _cnt;
String _val;
String _index;
int pinErrors;
public:
LineParsing() :
_key{""},
_file{""},
_page{""},
_descr{""},
_order{""},
_addr{""},
_reg{""},
_pin{""},
_map{""},
_c{""},
_inv{""},
_state{""},
_db{""},
_type{""},
_int{""},
_cnt{""},
_val{""},
_index{""},
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("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 (_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 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;
}
int getPinErrors() {
return pinErrors;
}
void clearErrors() {
pinErrors = 0;
}
void clear() {
_key = "";
_file = "";
_page = "";
_descr = "";
_order = "";
_addr = "";
_reg = "";
_pin = "";
_map = "";
_c = "";
_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 (filename.indexOf("chart") != -1) jsonWriteStr(buf, "maxCount", _cnt);
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;

85
include/Class/ScenarioClass3.h
View File

@@ -1,85 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Cmd.h"
#include "Global.h"
class Scenario {
public:
void loop() {
if (!jsonReadBool(configSetupJson, "scen")) {
return;
}
String allBlocks = scenario;
allBlocks.replace("\r\n", "\n");
allBlocks.replace("\r", "\n");
allBlocks += "\n";
String incommingEvent = selectToMarker(eventBuf, ",");
String incommingEventKey = selectToMarker(incommingEvent, " ");
String incommingEventValue = selectToMarkerLast(incommingEvent, " ");
while (allBlocks.length() > 1) {
String oneBlock = selectToMarker(allBlocks, "end\n");
String condition = selectToMarker(oneBlock, "\n");
String setEventKey = selectFromMarkerToMarker(condition, " ", 0);
if (incommingEventKey == setEventKey) {
String setEventSign = selectFromMarkerToMarker(condition, " ", 1);
String setEventValue = selectFromMarkerToMarker(condition, " ", 2);
if (!isDigitDotCommaStr(setEventValue)) {
if (setEventValue.indexOf("+-") != -1) {
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;
}
} else {
setEventValue = getValue(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();
}
if (flag) {
//SerialPrint("I", "Scenario", "incomming Event Value: " + incommingEventValue);
//SerialPrint("I", "Scenario", "set Event Value: " + setEventValue);
oneBlock = deleteBeforeDelimiter(oneBlock, "\n");
oneBlock.replace("end", "");
SerialPrint("I", "Scenario", condition + " \n" + oneBlock);
spaceCmdExecute(oneBlock);
}
}
allBlocks = deleteBeforeDelimiter(allBlocks, "end\n");
}
eventBuf = deleteBeforeDelimiter(eventBuf, ",");
}
};
extern Scenario* myScenario;
extern void streamEventUDP(String event);

168
include/Clock.h
View File

@@ -1,168 +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", "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 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);

127
include/Consts.h
View File

@@ -1,127 +0,0 @@
#pragma once
#define FIRMWARE_VERSION 278
#ifdef esp8266_4mb
#define FIRMWARE_NAME "esp8266_4mb"
#define USE_LITTLEFS true
#define USE_OTA true
#define LED_PIN 2
#endif
#ifdef esp8266_1mb
#define FIRMWARE_NAME "esp8266_1mb"
#define USE_LITTLEFS false
#define USE_OTA false
#define LED_PIN 2
#endif
#ifdef esp32_4mb
#define FIRMWARE_NAME "esp32_4mb"
#define USE_LITTLEFS false
#define USE_OTA true
#define LED_PIN 22
#endif
#define NUM_BUTTONS 6
#define MQTT_RECONNECT_INTERVAL 20000
#define TELEMETRY_UPDATE_INTERVAL_MIN 60
#define DEVICE_CONFIG_FILE "s.conf.csv"
#define DEVICE_SCENARIO_FILE "s.scen.txt"
//=========System parts===========================================================================================================================================
//#define OTA_UPDATES_ENABLED
//#define MDNS_ENABLED
//#define WEBSOCKET_ENABLED
//#define LAYOUT_IN_RAM
//#define UDP_ENABLED
//#define SSDP_ENABLED
#define SensorBme280Enabled
#define SensorBmp280Enabled
#define SensorDhtEnabled
#define PwmOutEnable
#define telegramEnable
#define uartEnable
//================================================================================================================================================================
enum TimerTask_t { WIFI_SCAN,
WIFI_MQTT_CONNECTION_CHECK,
TIME,
TIME_SYNC,
STATISTICS,
UPTIME,
UDP,
SYGNAL };
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_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>
#include <analogWrite.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

152
include/Global.h
View File

@@ -1,152 +0,0 @@
#pragma once
//===================Libraries===================================================================================================================================================
#include "Consts.h"
#include <Arduino.h>
#include "CTBot.h"
#include <ArduinoJson.h>
#include <ArduinoOTA.h>
#include <Bounce2.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#include <PubSubClient.h>
#include <StringCommand.h>
#include <TickerScheduler.h>
#include <Wire.h>
#include <time.h>
#include "Clock.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;
extern boolean but[NUM_BUTTONS];
extern Bounce* buttons;
//Global vars
extern boolean just_load;
extern boolean telegramInitBeen;
// 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 chipId;
extern String prex;
extern String all_widgets;
extern String scenario;
//orders and events
extern String orderBuf;
extern String eventBuf;
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 inOutput_KeyList;
extern int inOutput_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 int dht_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;

9
include/HttpServer.h
View File

@@ -1,9 +0,0 @@
#pragma once
#include "Global.h"
namespace HttpServer {
void init();
} // namespace HttpServer

10
include/Init.h
View File

@@ -1,10 +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();

16
include/ItemsList.h
View File

@@ -1,16 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Global.h"
extern void itemsListInit();
extern void addItem2(int num);
extern void addItem(String name);
extern void addPreset(String name);
extern void addPreset2(int num);
extern void delChoosingItems();
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));

27
include/MqttClient.h
View File

@@ -1,27 +0,0 @@
#pragma once
#include <Arduino.h>
extern String mqttPrefix;
extern String mqttRootDevice;
void mqttInit();
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);
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 {
}

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;

18
include/SoftUART.h
View File

@@ -1,18 +0,0 @@
#pragma once
#include "Consts.h"
#ifdef uartEnable
#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 telegramEnable
#include "Global.h"
extern void sendTelegramMsg();
extern void telegramInit();
extern void handleTelegram();
extern bool isTelegramEnabled();
extern bool isTelegramInputOn();
extern void telegramMsgParse(String msg);
extern String returnListOfParams();
#endif

3
include/Tests.h
View File

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

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();
};

62
include/Utils/FileUtils.h
View File

@@ -1,62 +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);

21
include/Utils/JsonUtils.h
View File

@@ -1,21 +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);
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);

34
include/Utils/StringUtils.h
View File

@@ -1,34 +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);
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;
};
};

7
include/Utils/WebUtils.h
View File

@@ -1,7 +0,0 @@
#pragma once
#include "HttpServer.h"
#include <Arduino.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);

61
include/items/ButtonInClass.h
View File

@@ -1,61 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Class/LineParsing.h"
#include "Global.h"
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;

309
include/items/PZEMSensor.cpp
View File

@@ -1,309 +0,0 @@
#include "PZEMSensor.h"
#include <stdio.h>
#define REG_VOLTAGE 0x0000
#define REG_CURRENT_L 0x0001
#define REG_CURRENT_H 0X0002
#define REG_POWER_L 0x0003
#define REG_POWER_H 0x0004
#define REG_ENERGY_L 0x0005
#define REG_ENERGY_H 0x0006
#define REG_FREQUENCY 0x0007
#define REG_PF 0x0008
#define REG_ALARM 0x0009
#define CMD_RHR 0x03
#define CMD_RIR 0X04
#define CMD_WSR 0x06
#define CMD_CAL 0x41
#define CMD_REST 0x42
#define WREG_ALARM_THR 0x0001
#define WREG_ADDR 0x0002
#define UPDATE_TIME 200
#define RESPONSE_SIZE 32
#define READ_TIMEOUT 100
#define PZEM_BAUD_RATE 9600
#define DEBUG
// Debugging function;
void printBuf(uint8_t *buffer, uint16_t len) {
#ifdef DEBUG
for (uint16_t i = 0; i < len; i++) {
char temp[6];
sprintf(temp, "%.2x ", buffer[i]);
Serial.print(temp);
}
Serial.println();
#endif
}
PZEMSensor::PZEMSensor(SoftwareSerial *port, uint16_t addr) {
_serial = port;
_addr = addr;
}
PZEM_Info *PZEMSensor::values() {
// Update vales if necessary
if (!refresh()) {
_values = PZEM_Info();
}
return &_values;
}
/*!
* PZEM004Tv30::sendCmd8
*
* Prepares the 8 byte command buffer and sends
*
* @param[in] cmd - Command to send (position 1)
* @param[in] rAddr - Register address (postion 2-3)
* @param[in] val - Register value to write (positon 4-5)
* @param[in] check - perform a simple read check after write
*
* @return success
*/
bool PZEMSensor::sendCmd8(uint8_t cmd, uint16_t rAddr, uint16_t val, bool check, uint16_t slave_addr) {
uint8_t sendBuffer[8]; // Send buffer
uint8_t respBuffer[8]; // Response buffer (only used when check is true)
if ((slave_addr == 0xFFFF) ||
(slave_addr < 0x01) ||
(slave_addr > 0xF7)) {
slave_addr = _addr;
}
sendBuffer[0] = slave_addr; // Set slave address
sendBuffer[1] = cmd; // Set command
sendBuffer[2] = (rAddr >> 8) & 0xFF; // Set high byte of register address
sendBuffer[3] = (rAddr)&0xFF; // Set low byte =//=
sendBuffer[4] = (val >> 8) & 0xFF; // Set high byte of register value
sendBuffer[5] = (val)&0xFF; // Set low byte =//=
setCRC(sendBuffer, 8); // Set CRC of frame
_serial->write(sendBuffer, 8); // send frame
if (check) {
if (!recieve(respBuffer, 8)) { // if check enabled, read the response
return false;
}
// Check if response is same as send
for (uint8_t i = 0; i < 8; i++) {
if (sendBuffer[i] != respBuffer[i])
return false;
}
}
return true;
}
bool PZEMSensor::setAddress(uint8_t addr) {
if (addr < 0x01 || addr > 0xF7) // sanity check
return false;
// Write the new address to the address register
if (!sendCmd8(CMD_WSR, WREG_ADDR, addr, true))
return false;
_addr = addr; // If successful, update the current slave address
return true;
}
uint8_t PZEMSensor::getAddress() {
return _addr;
}
bool PZEMSensor::setPowerAlarm(uint16_t watts) {
if (watts > 25000) { // Sanitych check
watts = 25000;
}
// Write the watts threshold to the Alarm register
if (!sendCmd8(CMD_WSR, WREG_ALARM_THR, watts, true))
return false;
return true;
}
bool PZEMSensor::getPowerAlarm() {
if (!refresh()) // Update vales if necessary
return NAN; // Update did not work, return NAN
return _values.alarms != 0x0000;
}
void PZEMSensor::init() {
if (_addr < 0x01 || _addr > 0xF8) {
// Sanity check of address
_addr = PZEM_DEFAULT_ADDR;
}
// Set initial lastRed time so that we read right away
_lastRead = 0;
_lastRead -= UPDATE_TIME;
}
bool PZEMSensor::refresh() {
static uint8_t response[25];
if (_lastRead + UPDATE_TIME > millis()) {
return true;
}
// Read 10 registers starting at 0x00 (no check)
sendCmd8(CMD_RIR, 0x00, 0x0A, false);
if (recieve(response, 25) != 25) { // Something went wrong
return false;
}
// Update the current values
_values.voltage = ((uint32_t)response[3] << 8 | // Raw voltage in 0.1V
(uint32_t)response[4]) /
10.0;
_values.current = ((uint32_t)response[5] << 8 | // Raw current in 0.001A
(uint32_t)response[6] |
(uint32_t)response[7] << 24 |
(uint32_t)response[8] << 16) /
1000.0;
_values.power = ((uint32_t)response[9] << 8 | // Raw power in 0.1W
(uint32_t)response[10] |
(uint32_t)response[11] << 24 |
(uint32_t)response[12] << 16) /
10.0;
_values.energy = ((uint32_t)response[13] << 8 | // Raw Energy in 1Wh
(uint32_t)response[14] |
(uint32_t)response[15] << 24 |
(uint32_t)response[16] << 16) /
1000.0;
_values.freq = ((uint32_t)response[17] << 8 | // Raw Frequency in 0.1Hz
(uint32_t)response[18]) /
10.0;
_values.pf = ((uint32_t)response[19] << 8 | // Raw pf in 0.01
(uint32_t)response[20]) /
100.0;
_values.alarms = ((uint32_t)response[21] << 8 | // Raw alarm value
(uint32_t)response[22]);
// Record current time as _lastRead
_lastRead = millis();
return true;
}
bool PZEMSensor::reset() {
uint8_t buffer[] = {0x00, CMD_REST, 0x00, 0x00};
uint8_t reply[5];
buffer[0] = _addr;
setCRC(buffer, 4);
_serial->write(buffer, 4);
uint16_t length = recieve(reply, 5);
if (length == 0 || length == 5) {
return false;
}
return true;
}
uint16_t PZEMSensor::recieve(uint8_t *resp, uint16_t len) {
((SoftwareSerial *)_serial)->listen(); // Start software serial listen
unsigned long startTime = millis(); // Start time for Timeout
uint8_t index = 0; // Bytes we have read
while ((index < len) && (millis() - startTime < READ_TIMEOUT)) {
if (_serial->available() > 0) {
uint8_t c = (uint8_t)_serial->read();
resp[index++] = c;
}
}
// Check CRC with the number of bytes read
if (!checkCRC(resp, index)) {
return 0;
}
return index;
}
bool PZEMSensor::checkCRC(const uint8_t *buf, uint16_t len) {
if (len <= 2) // Sanity check
return false;
uint16_t crc = CRC16(buf, len - 2); // Compute CRC of data
return ((uint16_t)buf[len - 2] | (uint16_t)buf[len - 1] << 8) == crc;
}
void PZEMSensor::setCRC(uint8_t *buf, uint16_t len) {
if (len <= 2) // Sanity check
return;
uint16_t crc = CRC16(buf, len - 2); // CRC of data
// Write high and low byte to last two positions
buf[len - 2] = crc & 0xFF; // Low byte first
buf[len - 1] = (crc >> 8) & 0xFF; // High byte second
}
// Pre computed CRC table
static const uint16_t crcTable[] PROGMEM = {
0X0000, 0XC0C1, 0XC181, 0X0140, 0XC301, 0X03C0, 0X0280, 0XC241,
0XC601, 0X06C0, 0X0780, 0XC741, 0X0500, 0XC5C1, 0XC481, 0X0440,
0XCC01, 0X0CC0, 0X0D80, 0XCD41, 0X0F00, 0XCFC1, 0XCE81, 0X0E40,
0X0A00, 0XCAC1, 0XCB81, 0X0B40, 0XC901, 0X09C0, 0X0880, 0XC841,
0XD801, 0X18C0, 0X1980, 0XD941, 0X1B00, 0XDBC1, 0XDA81, 0X1A40,
0X1E00, 0XDEC1, 0XDF81, 0X1F40, 0XDD01, 0X1DC0, 0X1C80, 0XDC41,
0X1400, 0XD4C1, 0XD581, 0X1540, 0XD701, 0X17C0, 0X1680, 0XD641,
0XD201, 0X12C0, 0X1380, 0XD341, 0X1100, 0XD1C1, 0XD081, 0X1040,
0XF001, 0X30C0, 0X3180, 0XF141, 0X3300, 0XF3C1, 0XF281, 0X3240,
0X3600, 0XF6C1, 0XF781, 0X3740, 0XF501, 0X35C0, 0X3480, 0XF441,
0X3C00, 0XFCC1, 0XFD81, 0X3D40, 0XFF01, 0X3FC0, 0X3E80, 0XFE41,
0XFA01, 0X3AC0, 0X3B80, 0XFB41, 0X3900, 0XF9C1, 0XF881, 0X3840,
0X2800, 0XE8C1, 0XE981, 0X2940, 0XEB01, 0X2BC0, 0X2A80, 0XEA41,
0XEE01, 0X2EC0, 0X2F80, 0XEF41, 0X2D00, 0XEDC1, 0XEC81, 0X2C40,
0XE401, 0X24C0, 0X2580, 0XE541, 0X2700, 0XE7C1, 0XE681, 0X2640,
0X2200, 0XE2C1, 0XE381, 0X2340, 0XE101, 0X21C0, 0X2080, 0XE041,
0XA001, 0X60C0, 0X6180, 0XA141, 0X6300, 0XA3C1, 0XA281, 0X6240,
0X6600, 0XA6C1, 0XA781, 0X6740, 0XA501, 0X65C0, 0X6480, 0XA441,
0X6C00, 0XACC1, 0XAD81, 0X6D40, 0XAF01, 0X6FC0, 0X6E80, 0XAE41,
0XAA01, 0X6AC0, 0X6B80, 0XAB41, 0X6900, 0XA9C1, 0XA881, 0X6840,
0X7800, 0XB8C1, 0XB981, 0X7940, 0XBB01, 0X7BC0, 0X7A80, 0XBA41,
0XBE01, 0X7EC0, 0X7F80, 0XBF41, 0X7D00, 0XBDC1, 0XBC81, 0X7C40,
0XB401, 0X74C0, 0X7580, 0XB541, 0X7700, 0XB7C1, 0XB681, 0X7640,
0X7200, 0XB2C1, 0XB381, 0X7340, 0XB101, 0X71C0, 0X7080, 0XB041,
0X5000, 0X90C1, 0X9181, 0X5140, 0X9301, 0X53C0, 0X5280, 0X9241,
0X9601, 0X56C0, 0X5780, 0X9741, 0X5500, 0X95C1, 0X9481, 0X5440,
0X9C01, 0X5CC0, 0X5D80, 0X9D41, 0X5F00, 0X9FC1, 0X9E81, 0X5E40,
0X5A00, 0X9AC1, 0X9B81, 0X5B40, 0X9901, 0X59C0, 0X5880, 0X9841,
0X8801, 0X48C0, 0X4980, 0X8941, 0X4B00, 0X8BC1, 0X8A81, 0X4A40,
0X4E00, 0X8EC1, 0X8F81, 0X4F40, 0X8D01, 0X4DC0, 0X4C80, 0X8C41,
0X4400, 0X84C1, 0X8581, 0X4540, 0X8701, 0X47C0, 0X4680, 0X8641,
0X8201, 0X42C0, 0X4380, 0X8341, 0X4100, 0X81C1, 0X8081, 0X4040};
uint16_t PZEMSensor::CRC16(const uint8_t *data, uint16_t len) {
uint8_t nTemp; // CRC table index
uint16_t crc = 0xFFFF; // Default value
while (len--) {
nTemp = *data++ ^ crc;
crc >>= 8;
crc ^= (uint16_t)pgm_read_word(&crcTable[nTemp]);
}
return crc;
}
void PZEMSensor::search() {
static uint8_t response[7];
for (uint16_t addr = 0x01; addr <= 0xF8; addr++) {
sendCmd8(CMD_RIR, 0x00, 0x01, false, addr);
if (recieve(response, 7) != 7) {
// Something went wrong
continue;
} else {
Serial.print("Device on addr: ");
Serial.print(addr);
}
}
}

51
include/items/PZEMSensor.h
View File

@@ -1,51 +0,0 @@
#pragma once
#include <Arduino.h>
#include <SoftwareSerial.h>
#define PZEM_DEFAULT_ADDR 0xF8
struct PZEM_Info {
float voltage;
float current;
float power;
float energy;
float freq;
float pf;
uint16_t alarms;
PZEM_Info() : voltage{0}, current{0}, power{0}, energy{0}, freq{0}, pf{0}, alarms{0} {};
};
class PZEMSensor {
public:
PZEMSensor(SoftwareSerial *serial, uint16_t addr = PZEM_DEFAULT_ADDR);
~PZEMSensor();
PZEM_Info* values();
bool setAddress(uint8_t addr);
uint8_t getAddress();
bool setPowerAlarm(uint16_t watts);
bool getPowerAlarm();
bool reset();
void search();
// Get most up to date values from device registers and cache them
bool refresh();
private:
void init(void);
private:
PZEM_Info _values; // Measured values
Stream *_serial; // Serial interface
bool _isSoft; // Is serial interface software
uint8_t _addr; // Device address
uint64_t _lastRead; // Last time values were updated
void init(uint8_t addr); // Init common to all constructors
uint16_t recieve(uint8_t *resp, uint16_t len); // Receive len bytes into a buffer
bool sendCmd8(uint8_t cmd, uint16_t rAddr, uint16_t val, bool check = false, uint16_t slave_addr = 0xFFFF); // Send 8 byte command
void setCRC(uint8_t *buf, uint16_t len); // Set the CRC for a buffer
bool checkCRC(const uint8_t *buf, uint16_t len); // Check CRC of buffer
uint16_t CRC16(const uint8_t *data, uint16_t len); // Calculate CRC of buffer
};

32
include/items/SensorPower.h
View File

@@ -1,32 +0,0 @@
#pragma once
#include "Global.h"
#include "PZEMSensor.h"
class SensorPZEM {
public:
SensorPZEM(SoftwareSerial* serial, uint32_t addr, uint32_t interval, String key) : _lastUpdate{0},
_interval{interval},
_key{key} {
_pzem = new PZEMSensor(serial, addr);
}
~SensorPZEM() {
delete _pzem;
}
void loop(void);
private:
void readSensor(void);
String getDataKey(const char* param_key);
void post(const char* key, const String& value);
private:
PZEMSensor* _pzem;
uint32_t _lastUpdate;
uint32_t _interval;
String _key;
};
extern SensorPZEM* myPowerSensor;

31
include/items/vButtonOut.h
View File

@@ -1,31 +0,0 @@
#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();

34
include/items/vCountDown.h
View File

@@ -1,34 +0,0 @@
#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 currentMillis;
unsigned long prevMillis1;
unsigned long prevMillis2;
unsigned long difference1;
unsigned long difference2;
int sec;
};
extern MyCountDownVector* myCountDown;
extern void countDown();
extern void countDownExecute();

31
include/items/vImpulsOut.h
View File

@@ -1,31 +0,0 @@
#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();

27
include/items/vInOutput.h
View File

@@ -1,27 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Global.h"
class InOutput;
typedef std::vector<InOutput> MyInOutputVector;
class InOutput {
public:
InOutput(String key, String widget);
~InOutput();
void execute(String value);
private:
String _key;
};
extern MyInOutputVector* myInOutput;
extern void inOutput();
extern void inOutputExecute();

39
include/items/vLogging.h
View File

@@ -1,39 +0,0 @@
#pragma once
#include <Arduino.h>
#include "Global.h"
class LoggingClass;
typedef std::vector<LoggingClass> MyLoggingVector;
class LoggingClass {
public:
LoggingClass(unsigned long period, unsigned int maxPoints, String loggingValueKey, String key);
~LoggingClass();
void loop();
void execute(String keyOrValue);
private:
unsigned long currentMillis;
unsigned long prevMillis;
unsigned long difference;
unsigned long _period;
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();

31
include/items/vPwmOut.h
View File

@@ -1,31 +0,0 @@
#pragma once
#include "Consts.h"
#ifdef PwmOutEnable
#include <Arduino.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 @@
#pragma once
#include "Global.h"
#include <Arduino.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();

39
include/items/vSensorBme280.h
View File

@@ -1,39 +0,0 @@
#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();

38
include/items/vSensorBmp280.h
View File

@@ -1,38 +0,0 @@
#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();

39
include/items/vSensorCcs811.h
View File

@@ -1,39 +0,0 @@
#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();

37
include/items/vSensorDallas.h
View File

@@ -1,37 +0,0 @@
#pragma once
#include "Global.h"
#include <Arduino.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();

40
include/items/vSensorDht.h
View File

@@ -1,40 +0,0 @@
#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();

44
include/items/vSensorUltrasonic.h
View File

@@ -1,44 +0,0 @@
#pragma once
#include "Global.h"
#include <Arduino.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();

33
include/items/vSensorUptime.h
View File

@@ -1,33 +0,0 @@
#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();