Merge branch 'ver4dev' of https://github.com/IoTManagerProject/IoTManager into ver4dev

compilerProfile.json

@@ -144,6 +144,10 @@
                 "path": "src/modules/virtual/LogingDaily",
                 "active": true
             },
+            {
+                "path": "src/modules/virtual/Math",
+                "active": false
+            },
             {
                 "path": "src/modules/virtual/owmWeather",
                 "active": true

data_svelte/flashProfile.json

@@ -22,6 +22,10 @@
                 "path": "src/modules/virtual/LogingDaily",
                 "active": true
             },
+            {
+                "path": "src/modules/virtual/Math",
+                "active": false
+            },
             {
                 "path": "src/modules/virtual/owmWeather",
                 "active": true

data_svelte/items.json

@@ -723,10 +723,11 @@
         "widget": "rangeServo",
         "page": "servo",
         "descr": "угол",
-        "int": 1,
         "pin": 12,
-        "apin": -1,
+        "minPulseWidth": 544,
-        "amap": "0, 4096, 0, 180",
+        "maxPulseWidth": 2400,
+        "neutralPulseWidth": 1500,
+        "trackingID": "",
         "num": 47
     },
     {

myProfile.json

@@ -144,6 +144,10 @@
                 "path": "src/modules/virtual/LogingDaily",
                 "active": true
             },
+            {
+                "path": "src/modules/virtual/Math",
+                "active": false
+            },
             {
                 "path": "src/modules/virtual/owmWeather",
                 "active": true

src/modules/exec/IoTServo/IoTServo.cpp

@@ -9,37 +9,41 @@ extern IoTGpio IoTgpio;
 class IoTServo : public IoTItem {
     private:
         Servo servObj;
-        int _apin, _oldValue;
+        // int _apin, _oldValue;
-        int _locmap1, _locmap2, _locmap3, _locmap4;
+        int _oldValue;
+        // int _locmap1, _locmap2, _locmap3, _locmap4;
 
     public:
         IoTServo(String parameters): IoTItem(parameters) {
-            int pin;
+            int pin, minPulseWidth, maxPulseWidth, neutralPulseWidth;
             jsonRead(parameters, "pin", pin);
-            servObj.attach(pin);
+            jsonRead(parameters, "minPulseWidth", minPulseWidth);
+            jsonRead(parameters, "maxPulseWidth", maxPulseWidth);
+            jsonRead(parameters, "neutralPulseWidth", neutralPulseWidth);
+            servObj.attach(pin, minPulseWidth, maxPulseWidth, neutralPulseWidth);
 
-            jsonRead(parameters, "apin", _apin);
+            // jsonRead(parameters, "apin", _apin);
-            if (_apin >= 0) IoTgpio.pinMode(_apin, INPUT);
+            // if (_apin >= 0) IoTgpio.pinMode(_apin, INPUT);
         
-            String map;
+            // String map;
-            jsonRead(parameters, F("amap"), map, false);
+            // jsonRead(parameters, F("amap"), map, false);
-            if (map != "") {
+            // if (map != "") {
-                _locmap1 = selectFromMarkerToMarker(map, ",", 0).toInt();
+            //     _locmap1 = selectFromMarkerToMarker(map, ",", 0).toInt();
-                _locmap2 = selectFromMarkerToMarker(map, ",", 1).toInt();
+            //     _locmap2 = selectFromMarkerToMarker(map, ",", 1).toInt();
-                _locmap3 = selectFromMarkerToMarker(map, ",", 2).toInt();
+            //     _locmap3 = selectFromMarkerToMarker(map, ",", 2).toInt();
-                _locmap4 = selectFromMarkerToMarker(map, ",", 3).toInt();
+            //     _locmap4 = selectFromMarkerToMarker(map, ",", 3).toInt();
-            }
+            // }
         }
 
-        void doByInterval() {
+        // void doByInterval() {
-            if (_apin >= 0) {
+        //     if (_apin >= 0) {
-                value.valD = map(IoTgpio.analogRead(_apin), _locmap1, _locmap2, _locmap3, _locmap4);
+        //         value.valD = map(IoTgpio.analogRead(_apin), _locmap1, _locmap2, _locmap3, _locmap4);
-                if (abs(_oldValue - value.valD) > 5) {
+        //         if (abs(_oldValue - value.valD) > 5) {
-                    _oldValue = value.valD;
+        //             _oldValue = value.valD;
-                    servObj.write(_oldValue);
+        //             servObj.write(_oldValue);
-                }
+        //         }
-            }
+        //     }
-        }
+        // }
 
         IoTValue execute(String command, std::vector<IoTValue> &param) {
             if (command == "rotate") { 

src/modules/exec/IoTServo/modinfo.json

@@ -10,10 +10,11 @@
             "widget": "rangeServo",
             "page": "servo",
             "descr": "угол",
-            "int": 1,
             "pin": 12,
-            "apin": -1,
+            "minPulseWidth": 544,
-            "amap": "0, 4096, 0, 180"
+            "maxPulseWidth": 2400,
+            "neutralPulseWidth": 1500,
+            "trackingID": ""
         }
     ],
     "about": {
@@ -30,10 +31,11 @@
         "title": "Сервопривод",
         "moduleDesc": "Предназначен для управления сервоприводом по уровню аналогово сигнала.",
         "propInfo": {
-            "int": "Пауза в секундах между опросами аналогового входа. Если 0, то читаем постоянно",
             "pin": "Пин, к которому подключен сервопривод",
-            "apin": "Номер GPIO аналогового пина. Если -1, то функция отключена.",
+            "minPulseWidth": "Минимальная длина импульса",
-            "amap": "Настройки преобразования значений аналога в нужный диапазон сервы, имеет смысл, если аналог включен."
+            "maxPulseWidth": "Максимальная длина импульса",
+            "neutralPulseWidth": "Нейтральная длина импульса",
+            "trackingID": "Идентификатор отслеживания значения другого элемента конфигурации, например, чтение аналога"
         },
         "retInfo": "Содержит текущее значение поворота",
         "funcInfo": [

src/modules/sensors/Ble/Ble.cpp

@@ -1,27 +1,139 @@
 #include "Global.h"
 #include "classes/IoTItem.h"
 #include <Arduino.h>
-#ifdef ESP32
 #include <NimBLEDevice.h>
 #include <decoder.h>
+#include <vector>
 
 // Создаем переменную для хранения данных с датчиков bluetooth
-StaticJsonDocument<JSON_BUFFER_SIZE * 4> BLEbuffer;
+// StaticJsonDocument<JSON_BUFFER_SIZE * 4> BLEbuffer;
-JsonObject extBLEdata = BLEbuffer.to<JsonObject>();
+// DynamicJsonDocument extBLEdata(JSON_BUFFER_SIZE * 4);
+// JsonObject extBLEdata = BLEbuffer.to<JsonObject>();
+class BleSens;
+std::vector<BleSens *> BleSensArray;
 
-BLEScan *pBLEScan;
+class BleSens : public IoTItem
-TheengsDecoder decoder;
+{
-StaticJsonDocument<512> doc;
+private:
+  // описание параметров передаваемых из настроек датчика из веба
+  String _MAC;
+  String _sensor;
+  int timeRecv;
+public:
+  String whoIAm(/*String &mac, String &sens*/)
+  {
+    // mac = _MAC;
+    // sens = _sensor;
+    return _MAC;
+  }
+
+  void setBLEdata(JsonObject extBLEdata)
+  {
+    if (_sensor == "last")
+    {
+      timeRecv = extBLEdata[_sensor].as<int>();
+      char *s;
+      s = TimeToString(millis() / 1000 - timeRecv / 1000);
+      value.isDecimal = 0;
+      if (timeRecv > 0)
+      {
+        value.valS = s;
+      }
+      else
+      {
+        value.valS = "";
+      }
+      regEvent(value.valS, _id);
+    }
+    else
+    {
+      String valStr = extBLEdata[_sensor].as<String>();
+      if (valStr != "null")
+      {
+        if (value.isDecimal == isDigitDotCommaStr(valStr))
+        {
+          value.isDecimal = 1;
+          value.valD = valStr.toFloat();
+          regEvent(value.valD, _id);
+        }
+        else
+        {
+          value.isDecimal = 0;
+          value.valS = valStr;
+          regEvent(value.valS, _id);
+        }
+      }
+      else
+      {
+        value.isDecimal = 0;
+        value.valS = "";
+        regEvent(value.valS, _id);
+      }
+    }
+  }
+  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 doByInterval()
+  {
+    if (_sensor == "last")
+    {
+      char *s;
+      s = TimeToString(millis() / 1000 - timeRecv / 1000);
+      value.isDecimal = 0;
+      if (timeRecv > 0)
+      {
+        value.valS = s;
+      }
+      else
+      {
+        value.valS = "";
+      }
+      regEvent(value.valS, _id);
+    }
+  }
+
+  BleSens(String parameters) : IoTItem(parameters)
+  {
+    _MAC = jsonReadStr(parameters, "MAC");
+    _sensor = jsonReadStr(parameters, "sensor");
+    BleSensArray.push_back(this);
+  }
+
+  ~BleSens(){};
+};
+
+//=======================================================================================================
+
+/** Callback to process the results of the last scan or restart it */
+void scanEndedCB(NimBLEScanResults results)
+{
+  int count = results.getCount();
+  SerialPrint("i", F("BLE"), "Scan done! "); // +"Devices found: " + String(count));
+  // pBLEScan->clearResults();
+}
 
 class BleScan : public IoTItem, BLEAdvertisedDeviceCallbacks
 {
 private:
-  //описание параметров передаваемых из настроек датчика из веба
+  // описание параметров передаваемых из настроек датчика из веба
   int _scanDuration;
   String _filter;
+  bool _debug;
+
+  StaticJsonDocument<512> doc;
+  BLEScan *pBLEScan;
+  TheengsDecoder decoder;
 
 public:
-  //=======================================================================================================
   std::string convertServiceData(std::string deviceServiceData)
   {
     int serviceDataLength = (int)deviceServiceData.length();
@@ -67,169 +179,77 @@ public:
 
     if (decoder.decodeBLEJson(BLEdata))
     {
-
       BLEdata.remove("manufacturerdata");
       BLEdata.remove("servicedata");
+      BLEdata.remove("type");
+      BLEdata.remove("cidc");
+      BLEdata.remove("acts");
+      BLEdata.remove("cont");
+      BLEdata.remove("track");
 
       String mac_address = BLEdata["id"].as<const char *>();
       mac_address.replace(":", "");
-
-      if (_filter != "")
-      {
-        if (BLEdata[_filter])
-        {
-          for (JsonPair kv : BLEdata)
-          {
-            extBLEdata[mac_address][kv.key()] = BLEdata[kv.key()];
-          }
-
       // дописываем время прихода пакета данных
-          extBLEdata[mac_address]["last"] = millis();
+      BLEdata["last"] = millis();
-        }
+      if (_debug)
-      }
-      else
       {
-        for (JsonPair kv : BLEdata)
+        if ((_filter != "" && BLEdata[_filter]) || _filter == "")
         {
-          extBLEdata[mac_address][kv.key()] = BLEdata[kv.key()];
+          //  for (JsonPair kv : BLEdata)
+          // {
+          // String val = BLEdata.as<String>();
+          String output;
+          serializeJson(BLEdata, output);
+          SerialPrint("i", F("BLE"), _id + " " + output);
+          //}
+        }
+      }
+      BLEdata.remove("servicedatauuid");
+      SerialPrint("i", F("BLE"), "found: " + mac_address);
+      // Перебираем все зарегистрированные сенсоры BleSens
+      for (std::vector<BleSens *>::iterator it = BleSensArray.begin();
+           it != BleSensArray.end(); ++it)
+      {
+        // Если это данные для нужного сенсора (по его МАКУ)
+        if ((*it)->whoIAm() == mac_address)
+          // то передаем ему json, дальше он сам разберется
+          (*it)->setBLEdata(BLEdata);
       }
-        // дописываем время прихода пакета данных
-        extBLEdata[mac_address]["last"] = millis();
     }
-    };
   }
 
   BleScan(String parameters) : IoTItem(parameters)
   {
     _scanDuration = jsonReadInt(parameters, "scanDuration");
     _filter = jsonReadStr(parameters, "filter");
+    jsonRead(parameters, "debug", _debug);
 
-    if (pBLEScan->isScanning() == false)
-    {
-      SerialPrint("i", F("BLE"), "Start Scanning...");
     BLEDevice::init("");
     pBLEScan = BLEDevice::getScan(); // create new scan
     pBLEScan->setAdvertisedDeviceCallbacks(this);
     pBLEScan->setActiveScan(false); // active scan uses more power, but get results faster
     pBLEScan->setInterval(100);
     pBLEScan->setWindow(99);    // less or equal setInterval value
+    pBLEScan->setMaxResults(0); // do not store the scan results, use callback only.
   }
-  }
-
-  //=======================================================================================================
 
   // doByInterval()
   void doByInterval()
   {
-
+    if (pBLEScan->isScanning() == false)
+    {
       if (_scanDuration > 0)
       {
-      BLEScanResults foundDevices = pBLEScan->start(_scanDuration, true);
+        SerialPrint("i", F("BLE"), "Start Scanning...");
-      int count = foundDevices.getCount();
+        pBLEScan->start(_scanDuration, scanEndedCB, false);
-      SerialPrint("i", F("BLE"), "Devices found: " + String(count));
+      }
-      SerialPrint("i", F("BLE"), "Scan done!");
-      pBLEScan->clearResults();
-    }
-    for (JsonPair kv : extBLEdata)
-    {
-      String val = extBLEdata[kv.key()].as<String>();
-      SerialPrint("i", F("BLE"), _id + " " + kv.key().c_str() + " " + val);
     }
   }
-
-  //=======================================================================================================
 
   ~BleScan(){};
 };
 
-class BleSens : public IoTItem
+//=======================================================================================================
-{
-private:
-  //описание параметров передаваемых из настроек датчика из веба
-  String _MAC;
-  String _sensor;
-
-public:
-  //=======================================================================================================
-  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;
-  }
-
-  BleSens(String parameters) : IoTItem(parameters)
-  {
-    _MAC = jsonReadStr(parameters, "MAC");
-    _sensor = jsonReadStr(parameters, "sensor");
-  }
-
-  //=======================================================================================================
-
-  // doByInterval()
-  void doByInterval()
-  {
-    if (_sensor == "last")
-    {
-      int valInt = extBLEdata[_MAC][_sensor].as<int>();
-      char *s;
-      s = TimeToString(millis() / 1000 - valInt / 1000);
-      value.isDecimal = 0;
-      if (valInt > 0)
-      {
-        value.valS = s;
-      }
-      else
-      {
-        value.valS = "";
-      }
-      regEvent(value.valS, _id);
-    }
-    else
-    {
-      String valStr = extBLEdata[_MAC][_sensor].as<String>();
-      if (valStr != "null")
-      {
-        if (value.isDecimal = isDigitDotCommaStr(valStr))
-        {
-          value.isDecimal = 1;
-          value.valD = valStr.toFloat();
-          regEvent(value.valD, _id);
-        }
-        else
-        {
-          value.isDecimal = 0;
-          value.valS = valStr;
-          regEvent(value.valS, _id);
-        }
-      }
-      else
-      {
-        value.isDecimal = 0;
-        value.valS = "";
-        regEvent(value.valS, _id);
-      }
-    }
-    }
-  //=======================================================================================================
-
-  ~BleSens(){};
-};
-#endif
-
-// Заглушка для ESP8266
-#ifdef ESP8266
-class Ble : public IoTItem
-{
-private:
-public:
-  Ble(String parameters) : IoTItem(parameters) {}
-};
-#endif
 
 void *getAPI_Ble(String subtype, String param)
 {

src/modules/sensors/Ble/modinfo.json

@@ -3,7 +3,6 @@
   "configItem": [
     {
       "name": "bluetooth сканер",
-      "num": 1,
       "type": "Reading",
       "subtype": "BleScan",
       "id": "BleScan",
@@ -12,11 +11,11 @@
       "descr": "",
       "int": 135,
       "scanDuration": 10,
-      "filter": "servicedatauuid"
+      "filter": "servicedatauuid",
+      "debug":1
     },
     {
       "name": "bluetooth датчик",
-      "num": 1,
       "type": "Reading",
       "subtype": "BleSens",
       "id": "BleSens",
@@ -24,20 +23,20 @@
       "page": "Сенсоры",
       "descr": "",
       "needSave": 0,
+      "int": 30,
       "global": 0,
       "round": 1,
-      "int": 60,
       "MAC": "",
       "sensor": ""
     }
   ],
   "about": {
-    "authorName": "AVAKS",
+    "authorName": "AVAKS, v3 - Mit4bmw",
-    "authorContact": "https://t.me/@avaks_dev",
+    "authorContact": "https://t.me/@avaks, https://t.me/Mit4bmw",
-    "authorGit": "https://github.com/avaksru",
+    "authorGit": "https://github.com/avaksru, https://github.com/Mit4el",
     "specialThanks": "@Serghei63",
     "moduleName": "Ble",
-    "moduleVersion": "1.0",
+    "moduleVersion": "3.0",
     "usedRam": {
       "esp32_4mb": 1261449,
       "esp8266_4mb": 0
@@ -50,9 +49,9 @@
     "moduleDesc": "Позволяет получить данные с Bluetooth часов и термометров Mijia, Xiaomi, Cleargrass, ...",
     "propInfo": {
       "round": "Округление после запятой.",
-      "int": "Интервал сканирования BLE окружения (BleScan) / Интервал отправки собранной телеметрии в MQTT (BleSens)",
+      "int": "Интервал сканирования BLE окружения (BleScan) / В BleSens темп обновления времнени поступления данных, сами даные обновляются по мене сканирования/поступления",
       "scanDuration": "Длительность сканирования ",
-      "filter": "Позволяет установить фильтр по параметру передаваемому датчиком. Данные будут считываться только с датчиков у которых есть передаваемый параметр указанный в фильтре",
+      "filter": "Позволяет установить фильтр по параметру передаваемому датчиком. Влияет только на вывод лога при debug=1, что бы было легче найти датчики, если много устройств в эфире",
       "MAC": "MAC адрес беспроводного датчика",
       "sensor": "Тип сенсора: температура / влажность / время / ...   "
     }
@@ -61,15 +60,27 @@
   "usedLibs": {
     "esp32_4mb": [
       "https://github.com/h2zero/NimBLE-Arduino.git",
-      "https://github.com/avaksru/decoder.git"
+      "https://github.com/Mit4el/decoder.git"
+    ],
+    "esp32_16mb": [
+      "https://github.com/h2zero/NimBLE-Arduino.git",
+      "https://github.com/Mit4el/decoder.git"
     ],
     "esp32_4mb3f": [
       "https://github.com/h2zero/NimBLE-Arduino.git",
-      "https://github.com/avaksru/decoder.git"
+      "https://github.com/Mit4el/decoder.git"
     ],    
     "esp32cam_4mb": [
       "https://github.com/h2zero/NimBLE-Arduino.git",
-      "https://github.com/avaksru/decoder.git"
+      "https://github.com/Mit4el/decoder.git"
+    ],    
+    "esp32s3_16mb": [
+      "https://github.com/h2zero/NimBLE-Arduino.git",
+      "https://github.com/Mit4el/decoder.git"
+    ],    
+    "esp32c3m_4mb": [
+      "https://github.com/h2zero/NimBLE-Arduino.git",
+      "https://github.com/Mit4el/decoder.git"
     ]
   }
 }

src/modules/sensors/RTC/RTC.cpp

@@ -63,6 +63,42 @@ class RTC : public IoTItem {
                 valTmp.valS = _watch->gettime(param[0].valS + " ");
                 return valTmp;
             }
+        } else if (command == "setUnixTime") {
+            if (param.size() == 1) {
+                long ut = strtoul(param[0].valS.c_str(), nullptr, 10);
+                _watch->settimeUnix(ut);
+                return {};
+            }
+        } else if (command == "setTime") {
+            if (param.size() == 6) {
+                _watch->settime(param[0].valD, param[1].valD, param[2].valD, param[3].valD, param[4].valD, param[5].valD);      //сек, мин, час, день, мес, год
+                return {};
+            }
+        } else if (command == "getTimeFloat") {
+            if (param.size() == 1) {
+                IoTValue valTmp;
+                _watch->gettime();
+                valTmp.isDecimal = true;
+                String type = param[0].valS;
+                    if (type == "H") {
+                        valTmp.valD = static_cast<float>(_watch->Hours);
+                    } else if (type == "i") {
+                        valTmp.valD = static_cast<float>(_watch->minutes);
+                    } else if (type == "s") {
+                        valTmp.valD = static_cast<float>(_watch->seconds);
+                    } else if (type == "w") {
+                        valTmp.valD = static_cast<float>(_watch->weekday);                        
+                    } else if (type == "d") {
+                        valTmp.valD = static_cast<float>(_watch->day);      
+                    } else if (type == "m") {
+                        valTmp.valD = static_cast<float>(_watch->month);
+                    } else if (type == "Y") {
+                        valTmp.valD = static_cast<float>(_watch->year);                                           
+                    } else {
+                        return {};  // Если переданный тип не поддерживается
+                    }
+                return valTmp;
+            }
         }
 
         return {}; 

src/modules/sensors/RTC/modinfo.json

@@ -54,6 +54,27 @@
                 "params": [
                     "Формат как у функции date() в PHP"
                 ]
+            },
+            {
+                "name": "setTime",
+                "descr": "Установить время через сценарии в формате сек, мин, час, день, мес, год.",
+                "params": [
+                    "сек", "мин", "час", "день", "мес", "год"
+                ]
+            },
+            {
+                "name": "setUnixTime",
+                "descr": "Установить время через сценарий в формате юникстайм",
+                "params": [
+                    "rtc.setUnixTime('46489234') - параметр в виде строки"
+                ]
+            },
+            {
+                "name": "getTimeFloat",
+                "descr": "Получить числовое значение времени по указанному формату",
+                "params": [
+                    "s - Вернуть секунды, i - Вернуть минуты, H - Вернуть часы в 24-часовом формате, d - Вернуть день месяца, w - Вернуть день недели, m - Вернуть месяц, Y - Вернуть год(4 знака)"
+                ]
             }
         ]
     },

src/modules/virtual/Math/Math.cpp

@@ -0,0 +1,69 @@
+#include "Global.h"
+#include "classes/IoTItem.h"
+#include <ctime>
+
+class IoTMath : public IoTItem {
+private:
+
+    time_t convertTime(float day, float month, float year, float hour, float minute) {
+        // Преобразование из float в int
+        int d = static_cast<int>(day);
+        int m = static_cast<int>(month);
+        int y = static_cast<int>(year);
+        int h = static_cast<int>(hour);
+        int min = static_cast<int>(minute);
+
+        if (d < 1 || d > 31 || m < 1 || m > 12 || y < 1900 || h < 0 || h > 23 || min < 0 || min > 59) {
+            SerialPrint("E", F("IoTMath"), F("Invalid date or time parameters!"));
+            return -1;
+        }
+
+        // Структура для хранения даты и времени
+        struct tm t;
+        t.tm_year = y - 1900;
+        t.tm_mon = m - 1;
+        t.tm_mday = d;
+        t.tm_hour = h;
+        t.tm_min = min;
+        t.tm_sec = 0;
+        t.tm_isdst = -1;  // Пусть система сама определяет DST
+
+        return mktime(&t);
+    }
+
+public:
+    IoTMath(String parameters) : IoTItem(parameters) {}
+
+    IoTValue execute(String command, std::vector<IoTValue> &param) {
+        if(command == "map" && param.size() == 5) {
+            IoTValue valTmp;
+            valTmp.isDecimal = true;
+            valTmp.valD = map(param[0].valD, param[1].valD, param[2].valD, param[3].valD, param[4].valD);
+            //SerialPrint("i", F("IoTMath"), F("Mapping value done."));
+            return valTmp;
+        } else if(command == "convertTime" && param.size() == 5) {
+            time_t unixTime = convertTime(param[0].valD, param[1].valD, param[2].valD, param[3].valD, param[4].valD);
+
+            if (unixTime == -1) {
+                SerialPrint("E", F("IoTMath"), F("Failed to convert time."));
+                return {};
+            }
+
+            IoTValue valTmp;
+            valTmp.isDecimal = true;
+            valTmp.valD = unixTime;
+            //SerialPrint("i", F("IoTMath"), F("Time conversion done."));
+            return valTmp;
+        }
+
+        SerialPrint("E", F("IoTMath"), F("Unknown command or wrong parameters."));
+        return {};
+    }
+};
+
+void *getAPI_IoTMath(String subtype, String param) {
+    if (subtype == F("IoTMath")) {
+        return new IoTMath(param);
+    }
+    return nullptr;
+}

src/modules/virtual/Math/modinfo.json

@@ -0,0 +1,62 @@
+{
+    "menuSection": "virtual_elments",
+    "configItem": [
+        {
+            "global": 0,
+            "name": "Math library",
+            "type":  "Reading",
+            "subtype": "IoTMath",
+            "id": "math",
+            "widget": "anydataValue",
+            "page": "Математика",
+            "descr": ""
+        }
+    ],
+    "about": {
+        "authorName": "Berenbaum Maxim",
+        "authorContact": "https://t.me/Bermax_sys",
+        "authorGit": "https://github.com/xpohuk8",
+        "exampleURL": "https://iotmanager.org/wiki",
+        "specialThanks": "Ilya Belyakov",
+        "moduleName": "IoTMath",
+        "moduleVersion": "1.0",
+        "usedRam": {
+            "esp32_4mb": 15,
+            "esp8266_4mb": 15
+        },
+        "title": "Модуль Math",
+        "moduleDesc": "Модуль для расчета значений с использованием математических функций. Подходит для коррекции показаний датчиков.",
+        "propInfo": {
+        },
+        "funcInfo": [
+            {
+                "name": "map",
+                "descr": "Аналог функции map",
+                "params": [
+                    "Значение1", "Значение2", "Значение3", "Значение4"
+                ]
+            },
+            {
+                "name": "convertTime",
+                "descr": "Перевести время из формата d-m-Y H:i:s например, 13-08-2023 16:24:00  в юникс-время ",
+                "params": [
+                    "tm.convertTime(13, 08, 2023, 16, 24); - передаем пять целых чисел. секунды подставятся в ноль"
+                ]
+            }
+        ]
+    },
+    "defActive": true,
+    "usedLibs": {
+        "esp32_4mb": [],
+        "esp32_4mb3f": [],
+        "esp32cam_4mb": [],
+        "esp32s2_4mb": [],
+        "esp8266_4mb": [],
+        "esp8266_1mb": [],
+        "esp8266_1mb_ota": [],
+        "esp8285_1mb": [],
+        "esp8285_1mb_ota": [],
+        "esp8266_2mb": [],
+        "esp8266_2mb_ota": []
+    }
+}