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

Merge pull request #259 from IoTManagerProject/ver4dev

Browse Source 
Ver4dev
This commit is contained in:
Ilya Belyakov
2023-01-30 14:30:16 +03:00
committed by GitHub
parent 1f3e490d10 479b0fcfdd
commit d7560cb788
21 changed files with 804 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/MqttClient.cpp
View File

@@ -6,7 +6,7 @@ void mqttInit() {
WIFI_MQTT_CONNECTION_CHECK, MQTT_RECONNECT_INTERVAL,
[&](void*) {
if (WiFi.status() == WL_CONNECTED) {
SerialPrint("i", F("WIFI"), F("OK"));
SerialPrint("i", F("WIFI"), "OK: " + jsonReadStr(settingsFlashJson, F("ip")));
wifiUptimeCalc();
if (mqtt.connected()) {
SerialPrint("i", F("MQTT"), "OK");
@@ -110,8 +110,8 @@ void mqttSubscribe() {
mqtt.subscribe((mqttRootDevice + "/update").c_str());
if (jsonReadBool(settingsFlashJson, "mqttin")) {
mqtt.subscribe((mqttPrefix + "/+/+/event").c_str());
mqtt.subscribe((mqttPrefix + "/+/+/order").c_str());
mqtt.subscribe((mqttPrefix + "/+/+/event/#").c_str());
mqtt.subscribe((mqttPrefix + "/+/+/order/#").c_str());
mqtt.subscribe((mqttPrefix + "/+/+/info").c_str());
}
}

11
src/classes/IoTItem.cpp
View File

@@ -63,6 +63,7 @@ void IoTItem::setValue(const String& valStr, bool genEvent) {
if (value.isDecimal) {
value.valD = valStr.toFloat();
getRoundValue();
} else {
value.valS = valStr;
}
@@ -105,7 +106,7 @@ void IoTItem::regEvent(const String& value, const String& consoleInfo, bool erro
}
// отправка события другим устройствам в сети если не было ошибки
if (jsonReadBool(settingsFlashJson, "mqttin") && _global && !error) {
if (_global && !error) {
String json = "{}";
jsonWriteStr_(json, "id", _id);
jsonWriteStr_(json, "val", value);
@@ -117,15 +118,19 @@ void IoTItem::regEvent(const String& value, const String& consoleInfo, bool erro
}
String IoTItem::getRoundValue() {
if (!value.isDecimal) return value.valS;
if (_round >= 0 && _round <= 6) {
int sot = _round ? pow(10, (int)_round) : 1;
value.valD = round(value.valD * sot) / sot;
char buf[15];
sprintf(buf, ("%1." + (String)_round + "f").c_str(), value.valD);
return (String)buf;
value.valS = (String)buf;
return value.valS;
} else {
return (String)value.valD;
value.valS = (String)value.valD;
return value.valS;
}
}

83
src/classes/IoTScenario.cpp
View File

@@ -112,6 +112,7 @@ class VariableExprAST : public ExprAST {
// if (Item->value.isDecimal)
// Serial.printf("Call from VariableExprAST: %s = %f\n", Name.c_str(), Item->value.valD);
// else Serial.printf("Call from VariableExprAST: %s = %s\n", Name.c_str(), Item->value.valS.c_str());
Item->getRoundValue();
return &(Item->value);
}
@@ -125,7 +126,7 @@ class BinaryExprAST : public ExprAST {
signed char Op;
ExprAST *LHS, *RHS;
IoTValue val;
String lhsStr, rhsStr;
//String lhsStr, rhsStr;
public:
BinaryExprAST(signed char op, ExprAST *lhs, ExprAST *rhs)
@@ -139,21 +140,6 @@ class BinaryExprAST : public ExprAST {
IoTValue *exec() {
if (isIotScenException) return nullptr;
// String printStr = "";
// if (Op == tok_equal)
// printStr = "==";
// else if (Op == tok_notequal)
// printStr = "!=";
// else if (Op == tok_lesseq)
// printStr = "<=";
// else if (Op == tok_greateq)
// printStr = ">=";
// else
// printStr = printStr + (char)Op;
// Serial.printf("Call from BinaryExprAST: %s\n", printStr.c_str());
if (RHS == nullptr || LHS == nullptr) return nullptr;
IoTValue *rhs = RHS->exec(); // получаем значение правого операнда для возможного использования в операции присваивания
@@ -170,8 +156,12 @@ class BinaryExprAST : public ExprAST {
IoTValue *lhs = LHS->exec(); // если присваивания не произошло, значит операция иная и необходимо значение левого операнда
if (lhs == nullptr) return nullptr;
if (lhs->isDecimal && rhs->isDecimal) {
// все бинарные операции кроме +, - и == обязаны работать с числами
if (Op != '+' && Op != '-' && Op != tok_equal) {
// поэтому преобразовываем строки в булевые интерпретации
if (!lhs->isDecimal) lhs->valD = lhs->valS != ""; // пустая строка = false
if (!rhs->isDecimal) rhs->valD = rhs->valS != ""; // пустая строка = false
switch (Op) {
case '>':
val.valD = lhs->valD > rhs->valD;
@@ -185,19 +175,10 @@ class BinaryExprAST : public ExprAST {
case tok_greateq:
val.valD = lhs->valD >= rhs->valD;
break;
case tok_equal:
val.valD = lhs->valD == rhs->valD;
break;
case tok_notequal:
val.valD = lhs->valD != rhs->valD;
break;
case '+':
val.valD = lhs->valD + rhs->valD;
break;
case '-':
val.valD = lhs->valD - rhs->valD;
break;
case '*':
val.valD = lhs->valD * rhs->valD;
break;
@@ -218,37 +199,43 @@ class BinaryExprAST : public ExprAST {
default:
break;
}
return &val;
}
if (!lhs->isDecimal || !rhs->isDecimal) {
if (lhs->isDecimal)
lhsStr = (String)lhs->valD;
else
lhsStr = lhs->valS;
if (rhs->isDecimal)
rhsStr = (String)rhs->valD;
else
rhsStr = rhs->valS;
} else { // иначе имеем дело с операциями + или - или ==, которые могут работать с разными типами данных
if (lhs->isDecimal && lhs->valS == "") lhs->valS = (String)lhs->valD; // небольшой костыль пока не переделаем работу со значениями, планируется добавить long, работу со временем, перенести округление и модификаторы в IoTValue
if (rhs->isDecimal && rhs->valS == "") rhs->valS = (String)rhs->valD; // пока для сохранения округления в IoTItem применяется хитрость с сохранением внешнего вида числа в строку valS,
// но некоторые модули и системные не делают этого, поэтому отлавливаем эту ситуацию тут и учитываем.
switch (Op) {
case tok_equal:
val.valD = compStr(lhsStr, rhsStr);
if (lhs->isDecimal && rhs->isDecimal)
val.valD = lhs->valD == rhs->valD;
else
val.valD = compStr(lhs->valS, rhs->valS);
break;
case '+':
val.valS = lhsStr + rhsStr;
val.valD = 1;
val.isDecimal = false;
if (lhs->isDecimal && rhs->isDecimal)
val.valD = lhs->valD + rhs->valD;
else {
val.valS = lhs->valS + rhs->valS;
val.valD = 1;
val.isDecimal = false;
}
break;
case '-':
if (lhs->isDecimal && rhs->isDecimal)
val.valD = lhs->valD - rhs->valD;
else {
val.valS = lhs->valS;
val.valS.replace(rhs->valS, "");
val.valD = 1;
val.isDecimal = false;
}
break;
default:
break;
}
return &val;
}
}
return &val;
}

2
src/modules/API.cpp
View File

@@ -5,6 +5,7 @@ void* getAPI_Loging(String subtype, String params);
void* getAPI_LogingDaily(String subtype, String params);
void* getAPI_Timer(String subtype, String params);
void* getAPI_Variable(String subtype, String params);
void* getAPI_VariableColor(String subtype, String params);
void* getAPI_VButton(String subtype, String params);
void* getAPI_Acs712(String subtype, String params);
void* getAPI_AhtXX(String subtype, String params);
@@ -36,6 +37,7 @@ if ((tmpAPI = getAPI_Loging(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_LogingDaily(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_Timer(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_Variable(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_VariableColor(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_VButton(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_Acs712(subtype, params)) != nullptr) return tmpAPI;
if ((tmpAPI = getAPI_AhtXX(subtype, params)) != nullptr) return tmpAPI;

85
src/modules/exec/Mcp23008/Mcp23008.cpp Normal file
View File

@@ -0,0 +1,85 @@
#include "Global.h"
#include "classes/IoTItem.h"
#include "classes/IoTGpio.h"
#include <Adafruit_MCP23X08.h>
class Mcp23008Driver : public IoTGpio {
private:
Adafruit_MCP23X08 _mcp;
public:
Mcp23008Driver(int index, String addr) : IoTGpio(index) {
if (!_mcp.begin_I2C(hexStringToUint8(addr))) {
Serial.println("MCP23X08 Init Error.");
}
}
void pinMode(uint8_t pin, uint8_t mode) {
_mcp.pinMode(pin, mode);
}
void digitalWrite(uint8_t pin, uint8_t val) {
_mcp.digitalWrite(pin, val);
}
int digitalRead(uint8_t pin) {
return _mcp.digitalRead(pin);
}
void digitalInvert(uint8_t pin) {
_mcp.digitalWrite(pin, 1 - _mcp.digitalRead(pin));
}
~Mcp23008Driver() {};
};
class Mcp23008 : public IoTItem {
private:
Mcp23008Driver* _driver;
String _addr;
public:
Mcp23008(String parameters) : IoTItem(parameters) {
_driver = nullptr;
jsonRead(parameters, "addr", _addr);
if (_addr == "") {
scanI2C();
return;
}
int index;
jsonRead(parameters, "index", index);
if (index > 4) {
Serial.println("MCP23X08 wrong index. Must be 0 - 4");
return;
}
_driver = new Mcp23008Driver(index, _addr);
}
void doByInterval() {
if (_addr == "") {
scanI2C();
return;
}
}
//возвращает ссылку на экземпляр класса Mcp23008Driver
IoTGpio* getGpioDriver() {
return _driver;
}
~Mcp23008() {
delete _driver;
};
};
void* getAPI_Mcp23008(String subtype, String param) {
if (subtype == F("Mcp23008")) {
return new Mcp23008(param);
} else {
return nullptr;
}
}

67
src/modules/exec/Mcp23008/modinfo.json Normal file
View File

@@ -0,0 +1,67 @@
{
"menuSection": "Исполнительные устройства",
"configItem": [{
"global": 0,
"name": "Расширитель портов Mcp23008",
"type": "Reading",
"subtype": "Mcp23008",
"id": "Mcp",
"widget": "",
"page": "",
"descr": "",
"int": "0",
"addr": "0x20",
"index": 1
}],
"about": {
"authorName": "Ilya Belyakov",
"authorContact": "https://t.me/Biveraxe",
"authorGit": "https://github.com/biveraxe",
"specialThanks": "",
"moduleName": "Mcp23008",
"moduleVersion": "1.0",
"usedRam": {
"esp32_4mb": 15,
"esp8266_4mb": 15
},
"title": "Расширитель портов Mcp23008",
"moduleDesc": "Добавляет в систему дополнительные GPIO для элементов, которые поддерживают такую функцию.",
"propInfo": {
"int": "Не используется",
"addr": "Адрес устройства на шине, обычно 0x20",
"index": "Значения от 1 до 4, где при выборе 1 будет нумерация pin 100-115, при выборе 2 200-215 и т.д."
}
},
"defActive": false,
"usedLibs": {
"esp32_4mb": [
"adafruit/Adafruit Mcp23017 Arduino Library@^2.1.0",
"adafruit/Adafruit BusIO @ ^1.13.2"
],
"esp8266_4mb": [
"adafruit/Adafruit Mcp23017 Arduino Library@^2.1.0",
"adafruit/Adafruit BusIO @ ^1.13.2"
],
"esp8266_1mb": [
"adafruit/Adafruit Mcp23017 Arduino Library@^2.1.0",
"adafruit/Adafruit BusIO @ ^1.13.2"
],
"esp8266_1mb_ota": [
"adafruit/Adafruit Mcp23017 Arduino Library@^2.1.0",
"adafruit/Adafruit BusIO @ ^1.13.2"
],
"esp8285_1mb": [
"adafruit/Adafruit Mcp23017 Arduino Library@^2.1.0",
"adafruit/Adafruit BusIO @ ^1.13.2"
],
"esp8285_1mb_ota": [
"adafruit/Adafruit Mcp23017 Arduino Library@^2.1.0",
"adafruit/Adafruit BusIO @ ^1.13.2"
]
}
}

2
src/modules/exec/MySensors/MySensorsGate.h
View File

@@ -1,5 +1,7 @@
#pragma once
#include "Const.h"
#define MYSENSORS
#ifdef MYSENSORS
/*

133
src/modules/sensors/ExternalMQTT/ExternalMQTT.cpp Normal file
View File

@@ -0,0 +1,133 @@
#include "Global.h"
#include "classes/IoTItem.h"
class ExternalMQTT : public IoTItem
{
private:
String _MAC;
String _sensor;
IoTItem *tmp;
int _minutesPassed = 0;
String json = "{}";
int orange = 0;
int red = 0;
int offline = 0;
bool dataFromNode = false;
public:
ExternalMQTT(String parameters) : IoTItem(parameters)
{
_MAC = jsonReadStr(parameters, "MAC");
_sensor = jsonReadStr(parameters, "sensor");
jsonRead(parameters, F("orange"), orange);
jsonRead(parameters, F("red"), red);
jsonRead(parameters, F("offline"), offline);
dataFromNode = false;
}
char *TimeToString(unsigned long t)
{
static char str[12];
long h = t / 3600;
t = t % 3600;
int m = t / 60;
int s = t % 60;
sprintf(str, "%02ld:%02d:%02d", h, m, s);
return str;
}
void onMqttRecive(String &topic, String &msg)
{
if (msg.indexOf("HELLO") == -1)
{
// SerialPrint("i", "onMqttRecive", "Прилетело " + topic);
// SerialPrint("i", "onMqttRecive", "Прилетело " + msg);
String dev = selectToMarkerLast(topic, "/");
dev.toUpperCase();
dev.replace(":", "");
if (_MAC == "")
{
SerialPrint("i", "onMqttRecive", dev + " --> " + msg);
}
DynamicJsonDocument doc(JSON_BUFFER_SIZE);
DeserializationError error = deserializeJson(doc, msg);
if (error)
{
SerialPrint("E", F("onMqttRecive"), error.f_str());
}
JsonObject jsonObject = doc.as<JsonObject>();
for (JsonPair kv : jsonObject)
{
String key = kv.key().c_str();
String val = kv.value();
if (_MAC == dev && _sensor == key)
{
dataFromNode = true;
_minutesPassed = 0;
setValue(val);
// setNewWidgetAttributes();
}
// Serial.println("Key: " + key);
// Serial.println("Value: " + val);
}
}
}
void doByInterval()
{
_minutesPassed++;
setNewWidgetAttributes();
}
void onMqttWsAppConnectEvent()
{
setNewWidgetAttributes();
}
void setNewWidgetAttributes()
{
jsonWriteStr(json, F("info"), prettyMinutsTimeout(_minutesPassed));
if (dataFromNode)
{
if (orange != 0 && red != 0 && offline != 0)
{
if (_minutesPassed < orange)
{
jsonWriteStr(json, F("color"), "");
}
if (_minutesPassed >= orange && _minutesPassed < red)
{
jsonWriteStr(json, F("color"), F("orange")); // сделаем виджет оранжевым
}
if (_minutesPassed >= red && _minutesPassed < offline)
{
jsonWriteStr(json, F("color"), F("red")); // сделаем виджет красным
}
if (_minutesPassed >= offline)
{
jsonWriteStr(json, F("info"), F("offline"));
}
}
}
else
{
jsonWriteStr(json, F("info"), F("awaiting"));
}
sendSubWidgetsValues(_id, json);
}
~ExternalMQTT(){};
};
void *getAPI_ExternalMQTT(String subtype, String param)
{
if (subtype == F("ExternalMQTT"))
{
return new ExternalMQTT(param);
}
else
{
return nullptr;
}
}

58
src/modules/sensors/ExternalMQTT/modinfo.json Normal file
View File

@@ -0,0 +1,58 @@
{
"menuSection": "Сенсоры",
"configItem": [
{
"global": 0,
"name": "MQTT парсер",
"type": "Reading",
"subtype": "ExternalMQTT",
"id": "MQTTin",
"widget": "",
"page": "",
"descr": "",
"MAC": "",
"sensor": "",
"round": "",
"orange": 60,
"red": 120,
"offline": 180,
"int": 60
}
],
"about": {
"authorName": "AVAKS",
"authorContact": "https://t.me/@avaks_dev",
"authorGit": "https://github.com/avaksru",
"specialThanks": "",
"moduleName": "ExternalMQTT",
"moduleVersion": "1",
"usedRam": {
"esp32_4mb": 15,
"esp8266_4mb": 15
},
"title": "ExternalMQTT",
"moduleDesc": "Модуль получения данных из OpenMQTTGateway, Zigbee2MQTT, SLS, Tasmota, NodeRead, HA, openHAB, Fhem, domotiz, EEdom",
"propInfo": {
"round": "Округление после запятой.",
"int": "Интервал для изменения цвета",
"orange": "количество минут после которого окрасить виджет в оранжевый цвет",
"red": "количество минут после которого окрасить виджет в красный цвет",
"offline": "количество минут после которого отобразить что устройство offline, если все три orange red и offline поставить в ноль - то функция окраски выключится",
"MAC": "MAC адрес беспроводного датчика",
"sensor": "Тип сенсора: температура / влажность / время / ... "
}
},
"defActive": false,
"usedLibs": {
"esp32_4mb": [],
"esp8266_4mb": [],
"esp8266_1mb": [],
"esp8266_1mb_ota": [],
"esp8285_1mb": [],
"esp8285_1mb_ota": []
}
}

315
src/modules/sensors/Pzem004t/PZEMSensor.cpp Normal file
View File

@@ -0,0 +1,315 @@
#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(Stream *port, uint16_t addr) {
_serial = port;
_addr = addr;
init();
}
PZEM_Info *PZEMSensor::values(bool &online) {
// Update vales if necessary
if (!refresh()) {
_values = PZEM_Info();
online = false;
} else {
online = true;
}
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;
}
bool PZEMSensor::search() {
bool ret = false;
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.println("Pzem " + String(addr));
ret = true;
}
}
return ret;
}

50
src/modules/sensors/Pzem004t/PZEMSensor.h Normal file
View File

@@ -0,0 +1,50 @@
#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(Stream *serial, uint16_t addr = PZEM_DEFAULT_ADDR);
~PZEMSensor();
PZEM_Info *values(bool &online);
bool setAddress(uint8_t addr);
uint8_t getAddress();
bool setPowerAlarm(uint16_t watts);
bool getPowerAlarm();
bool reset();
bool 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
};

19
src/modules/sensors/UART/Uart.cpp
View File

@@ -169,13 +169,15 @@ class UART : public IoTItem {
IoTValue execute(String command, std::vector<IoTValue> &param) {
if (command == "println") {
if (param.size() == 1) {
if (param[0].isDecimal) uartPrintln((String)param[0].valD);
else uartPrintln(param[0].valS);
//if (param[0].isDecimal) uartPrintln((String)param[0].valD);
//else uartPrintln(param[0].valS);
uartPrintln(param[0].valS);
}
} else if (command == "print") {
if (param.size() == 1) {
if (param[0].isDecimal) uartPrint((String)param[0].valD);
else uartPrint(param[0].valS);
//if (param[0].isDecimal) uartPrint((String)param[0].valD);
//else uartPrint(param[0].valS);
uartPrintln(param[0].valS);
}
} else if (command == "printHex") {
if (param.size() == 1) {
@@ -184,10 +186,11 @@ class UART : public IoTItem {
} else if (command == "printFFF") {
if (param.size() == 2) {
String strToUart = "";
if (param[0].isDecimal)
strToUart = param[0].valD;
else
strToUart = param[0].valS;
// if (param[0].isDecimal)
// strToUart = param[0].valD;
// else
// strToUart = param[0].valS;
strToUart = param[0].valS;
if (param[1].valD)
uartPrintFFF("\"" + strToUart + "\"");

2
src/modules/virtual/Timer/modinfo.json
View File

@@ -32,7 +32,7 @@
"title": "Таймер обратного отсчета",
"moduleDesc": "Добавляет инструмент таймеров обратного отсчета для организации периодичных операций или логических конструкций. Часто используется как вспомогательный элемент для автоматизации.",
"propInfo": {
"int": "Задает размер в секундах одного шага(тика) таймера.",
"int": "Задает размер в миллисекундах (1000 = 1сек) одного шага(тика) таймера.",
"countDown": "Начальное значение таймера, с которого начинается обратный отсчет. countDown=0 - бесконечный счет (имеет смысл при ticker=1, иначе таймер будет выключен), countDown=-1 - отключает таймер совсем (используется для запуска системы с выключенным таймером)",
"ticker": "Генерировать(1) или нет(0) события при каждом тике таймера.",
"repeat": "Сбрасывать(1) или нет(0) таймер в начальное состояние при достижении нуля.",

46
src/modules/virtual/VariableColor/VariableColor.cpp Normal file
View File

@@ -0,0 +1,46 @@
#include "Global.h"
#include "classes/IoTItem.h"
// дочь - родитель
class VariableColor : public IoTItem
{
private:
public:
VariableColor(String parameters) : IoTItem(parameters)
{
}
void doByInterval()
{
}
// событие когда пользователь подключается приложением или веб интерфейсом к усройству
void onMqttWsAppConnectEvent()
{
SerialPrint("i", "Connecting", "Dashbord open ");
regEvent(value.valS, "VariableColor", false, true);
}
IoTValue execute(String command, std::vector<IoTValue> &param)
{
if (command == "widget" && param.size() == 2)
{
String json = "{}";
jsonWriteStr(json, param[0].valS, param[1].valS);
sendSubWidgetsValues(_id, json);
}
return {};
}
};
void *getAPI_VariableColor(String subtype, String param)
{
if (subtype == F("VariableColor"))
{
return new VariableColor(param);
}
else
{
return nullptr;
}
}

46
src/modules/virtual/VariableColor/modinfo.json Normal file
View File

@@ -0,0 +1,46 @@
{
"menuSection": "Виртуальные элементы",
"configItem": [
{
"global": 0,
"name": "Цветной текст",
"type": "Reading",
"subtype": "VariableColor",
"id": "color",
"needSave": 0,
"widget": "anydataDef",
"page": "Вывод",
"descr": "Цветной текст",
"val": "...",
"round": 0
}
],
"about": {
"authorName": "AVAKS",
"authorContact": "https://t.me/@avaks_dev",
"authorGit": "https://github.com/avaksru",
"specialThanks": "",
"moduleName": "VariableColor",
"moduleVersion": "1",
"usedRam": {
"esp32_4mb": 15,
"esp8266_4mb": 15
},
"title": "Цветной текст",
"moduleDesc": "Текст с возможностью динамического изменения цвета",
"propInfo": {
"val": "Значение при старте"
}
},
"defActive": true,
"usedLibs": {
"esp32_4mb": [],
"esp8266_4mb": [],
"esp8266_1mb": [],
"esp8266_1mb_ota": [],
"esp8285_1mb": [],
"esp8285_1mb_ota": []
}
}

153
src/modules/virtual/Weather/Weather.cpp Normal file
View File

@@ -0,0 +1,153 @@
#include "Global.h"
#include "classes/IoTItem.h"
#include <ArduinoJson.h>
long prevWeatherMillis = millis() - 60001;
StaticJsonDocument<JSON_BUFFER_SIZE * 2> Weatherdoc;
extern IoTGpio IoTgpio;
class Weather : public IoTItem
{
private:
String _location;
String _param;
long interval;
public:
Weather(String parameters) : IoTItem(parameters)
{
_location = jsonReadStr(parameters, "location");
_param = jsonReadStr(parameters, "param");
jsonRead(parameters, F("int"), interval);
interval = interval * 1000 * 60 * 60; // интервал проверки погоды в часах
}
void getWeather()
{
String ret;
if (WiFi.status() == WL_CONNECTED)
{
// char c;
String payload;
WiFiClient client;
HTTPClient http;
http.begin(client, "http://live-control.com/iotm/weather.php");
http.addHeader("Content-Type", "application/x-www-form-urlencoded");
String httpRequestData = "loc=" + _location;
int httpResponseCode = http.POST(httpRequestData);
if (httpResponseCode > 0)
{
ret = httpResponseCode;
if (httpResponseCode == HTTP_CODE_OK)
{
payload = http.getString();
deserializeJson(Weatherdoc, payload);
// ret += payload;
}
}
else
{
ret = http.errorToString(httpResponseCode).c_str();
}
SerialPrint("<-", F("getWeather"), httpRequestData);
SerialPrint("->", F("getWeather"), "server: " + ret);
http.end();
}
}
void doByInterval()
{
if (prevWeatherMillis + 60000 < millis())
{
getWeather();
prevWeatherMillis = millis();
}
if (jsonReadStr(Weatherdoc["current_condition"][0], "temp_C", true) != "null")
{
if (_param == "temp_C")
{
value.valS = jsonReadStr(Weatherdoc["current_condition"][0], "temp_C", true);
}
if (_param == "avgtempC")
{
value.valS = jsonReadStr(Weatherdoc["weather"][0], "avgtempC", true);
}
if (_param == "humidity")
{
value.valS = jsonReadStr(Weatherdoc["current_condition"][0], "humidity", true);
}
if (_param == "weatherCode")
{
value.valS = jsonReadStr(Weatherdoc["current_condition"][0], "weatherCode", true);
}
if (_param == "sunrise")
{
value.valS = jsonReadStr(Weatherdoc["weather"][0]["astronomy"][0], "sunrise", true);
}
if (_param == "sunset")
{
value.valS = jsonReadStr(Weatherdoc["weather"][0]["astronomy"][0], "sunset", true);
}
if (_param == "rangetempC")
{
value.valS = jsonReadStr(Weatherdoc["weather"][0], "mintempC", true) + "..." + jsonReadStr(Weatherdoc["weather"][0], "maxtempC", true);
}
// погода на завтра
if (_param == "temp_C_tomorrow")
{
value.valS = jsonReadStr(Weatherdoc["weather"][1], "avgtempC", true);
}
if (_param == "rangetempC_tomorrow")
{
value.valS = jsonReadStr(Weatherdoc["weather"][1], "mintempC", true) + "..." + jsonReadStr(Weatherdoc["weather"][1], "maxtempC", true);
}
regEvent(value.valS, "Weather");
}
}
void loop()
{
if (enableDoByInt)
{
currentMillis = millis();
difference = currentMillis - prevMillis;
if (difference >= interval)
{
prevMillis = millis();
this->doByInterval();
}
}
}
IoTValue execute(String command, std::vector<IoTValue> &param)
{
if (command == "get")
{
getWeather();
doByInterval();
}
return {};
}
~Weather(){};
};
void *getAPI_Weather(String subtype, String param)
{
if (subtype == F("Weather"))
{
return new Weather(param);
}
else
{
return nullptr;
}
}

53
src/modules/virtual/Weather/modinfo.json Normal file
View File

@@ -0,0 +1,53 @@
{
"menuSection": "Виртуальные элементы",
"configItem": [
{
"global": 0,
"name": "Погода",
"type": "Reading",
"subtype": "Weather",
"id": "Weather",
"needSave": 0,
"widget": "anydataDef",
"page": "Погода",
"descr": "",
"int": 3,
"location": "Moscow",
"param": "temp_C",
"round": 0,
"val": "..."
}
],
"about": {
"authorName": "AVAKS",
"authorContact": "https://t.me/@avaks_dev",
"authorGit": "https://github.com/avaksru",
"specialThanks": "",
"moduleName": "Weather",
"moduleVersion": "1",
"usedRam": {
"esp32_4mb": 15,
"esp8266_4mb": 15
},
"title": "Погода",
"moduleDesc": "Получение погоды из интернет",
"propInfo": {
"location": "Город.",
"param": "temp_C - температура, humidity - влажность, weatherCode - погодный код, sunrise - рассвет, sunset - закат, rangetempC - (-3...-10 C), temp_C_tomorrow - температура завтра, rangetempC_tomorrow - (-3...-10 C) на завтра",
"int": "Интервал запроса погоды в часах"
}
},
"defActive": false,
"usedLibs": {
"esp32_4mb": [],
"esp8266_4mb": [],
"esp8266_1mb": [],
"esp8266_1mb_ota": [],
"esp8285_1mb": [],
"esp8285_1mb_ota": []
}
}