Arduino.ru

#include <ESP8266WiFi.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFiClientSecure.h>
#include <DHT.h>
#include <EEPROM.h>
LiquidCrystal_I2C _lcd1(0x27, 20, 4);
int _dispTempLength1=0;
boolean _isNeedClearDisp1;
DHT _dht1(0, DHT22, 11);
extern "C" 
{
    #include "user_interface.h"
}
bool En_128741382_1;
float data1_float_128741382_1;
float data2_float_128741382_1;
WiFiClientSecure client_128741382_1;
bool _ri__128741382_1= 0;
bool _ro__128741382_1= 0;
bool ESPControllerWifiClient_HRD = 0;
bool ESPControllerWifiClient_status = 1;
bool ESPControllerWifiClient_isDHCP = 1;
bool ESPControllerWifiClient_IsNeedReconect = 0;
bool ESPControllerWifiClient_workStatus = 1;
char ESPControllerWifiClient_SSID[40] = "Home";
char ESPControllerWifiClient_password[40] = "147852369";
IPAddress ESPControllerWifiClient_ip(0, 0, 0, 0);
IPAddress  ESPControllerWifiClient_dns (0, 0, 0, 1);
IPAddress  ESPControllerWifiClient_gateway (0, 0, 0, 1);
IPAddress ESPControllerWifiClient_subnet (255, 255, 255, 0);
uint8_t ESPControllerWifiClient_mac[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
bool isNeededCommitESP8266EEprom = 0;
float _dht1_humOut = 0.00;
float _dht1_tempOut = 0.00;
unsigned long _dht1Tti = 0UL;
bool _gen1I = 0;
bool _gen1O = 0;
unsigned long _gen1P = 0UL;
String _SysParRead_1_Out;
int _disp1oldLength = 0;
void setup()
{
    Wire.pins(4, 5);
    Wire.begin();
    delay(10);
    EEPROM.begin(5);
    if(((readByteFromEEPROM(0, 0, 0x0))) != 163) 
    {
        (updateByteToEEPROM(0, 0, 0x0, (163)));
        (updateUnsignedLongToEEPROM(1, 0, 0x0, (0)));
        EEPROM.commit();
    }
    ESPControllerWifiClient_ip = _ipAddressFromUnsignetLong(readUnsignedLongFromEEPROM(1, 0, 0x0));
    WiFi.mode(WIFI_STA);
    _esp8266WifiModuleClientReconnect();
    _lcd1.init();
    _lcd1.backlight();
    _dht1Tti = millis();
    client_128741382_1.setInsecure();
}
void loop()
{
    if (_isNeedClearDisp1) 
    {
        _lcd1.clear();
        _isNeedClearDisp1= 0;
    }
    if (isNeededCommitESP8266EEprom) 
    {
         EEPROM.commit();
        isNeededCommitESP8266EEprom=0;
    }
    if(ESPControllerWifiClient_IsNeedReconect) 
    {
        _esp8266WifiModuleClientReconnect();
        ESPControllerWifiClient_IsNeedReconect = 0;
    }
    ESPControllerWifiClient_status = WiFi.status() == WL_CONNECTED;
    if (ESPControllerWifiClient_status) 
    {
         if (! ESPControllerWifiClient_HRD) 
        {
            ESPControllerWifiClient_ip =  WiFi.localIP();
            ESPControllerWifiClient_subnet =  WiFi.subnetMask();
            ESPControllerWifiClient_gateway =  WiFi.gatewayIP();
            ESPControllerWifiClient_dns =  WiFi.dnsIP();
            WiFi.macAddress(ESPControllerWifiClient_mac);
            ESPControllerWifiClient_HRD = 1;
        }
    }
     else 
    {
        ESPControllerWifiClient_HRD = 0;
    }
    //Плата:1
    if(_isTimer(_dht1Tti, 1000)) 
    {
        _dht1_humOut = _dht1.readHumidity();
        _dht1_tempOut = _dht1.readTemperature();
        _dht1Tti = millis();
    }
    if (!(0)) 
    {
         if (! _gen1I) 
        {
            _gen1I = 1;
            _gen1O = 1;
            _gen1P = millis();
        }
    }
     else 
    {
        _gen1I = 0 ;
        _gen1O= 0;
    }
    if (_gen1I) 
    {
          if (_isTimer (_gen1P , 2000)) 
        {
             _gen1P = millis();
            _gen1O = ! _gen1O;
        }
    }
    En_128741382_1 = _gen1O;
    data1_float_128741382_1 = _dht1_tempOut;
    data2_float_128741382_1 = _dht1_humOut;
    _ro__128741382_1= 0;
    if ((En_128741382_1) &&(!_ri__128741382_1)) 
    {
        _ro__128741382_1= 1;
    }
    _ri__128741382_1=En_128741382_1;
    if(_ro__128741382_1)
    {
        sendData_128741382_1(data1_float_128741382_1, data2_float_128741382_1);
    }
    _SysParRead_1_Out = ESPControllerWifiClient_ip.toString();
    if (!(0)) 
    {
        _dispTempLength1 = ((_SysParRead_1_Out)).length();
        if (_disp1oldLength > _dispTempLength1) 
        {
            _isNeedClearDisp1 = 1;
        }
        _disp1oldLength = _dispTempLength1;
        _lcd1.setCursor(0, 0);
        _lcd1.print((_SysParRead_1_Out));
    }
     else 
    {
        if (_disp1oldLength > 0) 
        {
            _isNeedClearDisp1 = 1;
            _disp1oldLength = 0;
        }
    }
}
bool _isTimer(unsigned long startTime, unsigned long period)
{
    unsigned long currentTime;
    currentTime = millis();
    if (currentTime>= startTime) 
    {
        return (currentTime>=(startTime + period));
    }
     else 
    {
        return (currentTime >=(4294967295-startTime+period));
    }
}
void sendData_128741382_1(float data1, float data2)
{
    if (!client_128741382_1.connect("script.google.com", 443)) 
    {
        return;
    }
    String GAS_ID = "AKfycbyCTL1FLhwijxl5uFc792BEOuqDKsLfQ4TncoEq-8ReRdKV-prp9NpCaLV6oaanhm1QXg";
    String string_data1=String(data1);
    String string_data2=String(data2);
    String url = "/macros/s/" + GAS_ID + "/exec?temperature=" + string_data1 + "&humidity=" + string_data2;
    client_128741382_1.print(String("GET ")+url+" HTTP/1.1\r\n"+"Host: "+"script.google.com"+"\r\n"+"User-Agent: BuildFailureDetectorESP8266\r\n"+"Connection: close\r\n\r\n");
    while (client_128741382_1.connected()) 
    {
        String line = client_128741382_1.readStringUntil('\n');
        if (line == "\r") 
        {
            break;
        }
    }
    String line = client_128741382_1.readStringUntil('\n');
    line.startsWith("{\"state\":\"success\"");
}
byte readByteFromEEPROM(int addres, byte bitAddres, byte chipAddres)
{
    return EEPROM.read(addres);
}
void updateByteToEEPROM(int addres, byte bitAddres, byte chipAddres, byte value)
{
    isNeededCommitESP8266EEprom = 1;
    return EEPROM.write(addres, value);
}
unsigned long readUnsignedLongFromEEPROM(int addres, byte bitAddres, byte chipAddres)
{
    byte x[4];
    for(byte i = 0; i < 4; i++) 
    {
         x[i] = readByteFromEEPROM((addres+i),  bitAddres,  chipAddres);
    }
    unsigned long *y = (unsigned long *)&x;
    return y[0];
}
void updateUnsignedLongToEEPROM(int addres, byte bitAddres, byte chipAddres, unsigned long value)
{
    byte *x = (byte *)&value;
    for(byte i = 0; i < 4; i++) 
    {
        updateByteToEEPROM((addres+i),  bitAddres,  chipAddres, x[i]);
    }
}
int hexStrToInt(String instring)
{
    byte len = instring.length();
    if  (len == 0) return 0;
    int result = 0;
    for (byte i = 0; i < 8; i++)    // только первые 8 цыфар влезуть в uint32
    {
        char ch = instring[i];
        if (ch == 0) break;
        result <<= 4;
        if (isdigit(ch))
        result = result | (ch - '0');
        else result = result | (ch - 'A' + 10);
    }
    return result;
}
void _esp8266WifiModuleClientReconnect()
{
    if(_checkMacAddres(ESPControllerWifiClient_mac)) 
    {
          wifi_set_macaddr(0, const_cast<uint8*>(ESPControllerWifiClient_mac));
    }
    if(ESPControllerWifiClient_isDHCP) 
    {
         WiFi.config(0U, 0U, 0U, 0U, 0U);
    }
     else 
    {
        WiFi.config(ESPControllerWifiClient_ip, ESPControllerWifiClient_gateway, ESPControllerWifiClient_subnet, ESPControllerWifiClient_dns , ESPControllerWifiClient_dns);
    }
    WiFi.begin(ESPControllerWifiClient_SSID, ESPControllerWifiClient_password);
}
IPAddress _ipAddressFromUnsignetLong(unsigned long value)
{
    IPAddress result;
    byte *x = (byte *)&value;
    for (byte i = 0; i < 4; i++) 
    {
        result[i] =  x[i];
    }
    return result;
}
bool checkIPAdressString(String value)
{
    IPAddress temp;
    return temp.fromString(value);
}
IPAddress _ipAddressFromString(String value)
{
    IPAddress temp;
    temp.fromString(value);
    return temp;
}
unsigned long _unsignetLongFromIPAdress(IPAddress value)
{
    byte buufer[4] = {0, 0, 0, 0};
    for (byte i = 0; i < 4; i++) 
    {
        buufer[i] = value[i];
    }
    unsigned long *y = (unsigned long *)&buufer;
    return y[0];
}
bool _checkMacAddres(byte array[])
{
    bool result = 0;
    for (byte i = 0; i < 6; i++)
    {
        if (array[i] == 255) 
        {
            return 0;
        }
        if (array[i] > 0) 
        {
            result = 1;
        }
    }
    return result;
}
void _parseMacAddressString(String value, byte array[])
{
    int index;
    byte buffer[6] = {255, 255, 255, 255, 255, 255};
    byte raz = 0;
    String tempString;
    while ((value.length() > 0) && (raz <= 6)) 
    {
        index = value.indexOf(":");
        if (index == -1) 
        {
            tempString = value;
            value = "";
        }
         else 
        {
            tempString = value.substring(0, index);
            value = value.substring(index + 1);
        }
        buffer[raz] = byte(hexStrToInt(tempString));
        raz++;
    }
    if (_checkMacAddres(buffer))
    {
        for (byte i = 0; i < 6; i++)
        {
            array[i] = buffer[i];
        }
    }
}
bool _compareMacAddreses(byte array1[], byte array2[])
{
    for (byte i = 0; i < 6; i++)
    {
        if (array1[i] != array2[i]) 
        {
            return 0;
        }
    }
    return 1;
}
bool _compareMacAddresWithString(byte array[], String value)
{
    byte buffer[6] = {255, 255, 255, 255, 255, 255};
    _parseMacAddressString(value,  buffer);
    return _compareMacAddreses(array, buffer);
}
bool _checkMacAddresString(String value)
{
    byte buffer[6] = {255, 255, 255, 255, 255, 255};
    _parseMacAddressString(value,  buffer);
    return _checkMacAddres(buffer);
}
String _macAddresToString(byte array[])
{
    String result = "";
    String  temp ="";
    for (byte i = 0; i < 6; i++)
    {
        temp=String(array[i],HEX);
        if (temp.length()  < 2) 
        {
            temp = String("0") + temp;
        }
        result = result + temp;
        if (i < 5) 
        {
               result = result + String(":");
        }
    }
    result.toUpperCase();
    return result;
}