iotmanager/IoTManager
1
0
Fork 0
mirror of https://github.com/IoTManagerProject/IoTManager.git synced 2026-03-26 22:22:16 +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

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