Безумный дом. Датчик с батарейным питанием на базе ESP8266

void reset_RTC_counter(void)
{
  uint32_t bootcount =0;
  ESP.rtcUserMemoryWrite(0, &bootcount, sizeof(bootcount));  
}

uint16_t RTC_bootcount(void)
{
  uint32_t bootcount;
  uint16_t low_word; 
  uint16_t high_word; 
  uint16_t return_word; 
  ESP.rtcUserMemoryRead(0, &bootcount, sizeof(bootcount)); 
  low_word = bootcount & 0xFFFF;
  high_word = (bootcount>>16) & 0xFFFF;
  if (low_word!=high_word)
  {
    low_word = 0;
    high_word = 0;
  }
  return_word =  low_word;
  low_word++;
  high_word++;
  bootcount = (high_word << 16) + low_word;
  ESP.rtcUserMemoryWrite(0, &bootcount, sizeof(bootcount));
  return (return_word);
}

void SaveFloatRtc(float fnum1, float fnum2)
{
  union
  {
    uint32_t ltemp;  
    float ftemp;
  };
  ftemp = fnum1;
  ESP.rtcUserMemoryWrite(1, & ltemp, sizeof(ltemp));
  ftemp = fnum2;
  ESP.rtcUserMemoryWrite(2, & ltemp, sizeof(ltemp));
}

float GetFloatFromRtc(uint8_t offset)
{
  union
  {
    uint32_t ltemp;  
    float ftemp;
  };  
  ESP.rtcUserMemoryRead(offset+1, & ltemp, sizeof(ltemp)); 
  return ftemp;
}

mqtt:
  sensor:
    - name: "Temperature outside"
      state_topic: "garage/sensor/temperature/outside"
      unit_of_measurement: "°C"


    - name: "Temperature inside"
      state_topic: "garage/sensor/temperature/inside"
      unit_of_measurement: "°C"
      

    - name: "Battery Voltage"
      state_topic: "garage/sensor/battery_level"
      unit_of_measurement: "V"      
      
    - name: "Temperature boiler"
      state_topic: "workshop/sensor/temperature/boiler"
      unit_of_measurement: "°C"


    - name: "Temperature workshop"
      state_topic: "workshop/sensor/temperature/inside"
      unit_of_measurement: "°C"
      

    - name: "Workshop Battery Voltage"
      state_topic: "workshop/sensor/battery_level"
      unit_of_measurement: "V"      
      icon: mdi:battery-60 

#include <Arduino.h>
#include <Wire.h>
#include <DS18B20.h>
#include <ESP8266WiFi.h>
#include <ArduinoMqttClient.h>

#define DEBUG false
#define Serial if(DEBUG)Serial

#define TMP75_ADDRESS 0x48 

#define TMP75_TEMP_REGISTER 0
#define TMP75_CONF_REGISTER 1
#define TMP75_THYST_REGISTER 2
#define TMP75_TOS_REGISTER 3

#define TMP75_CONF_SHUTDOWN  0
#define TMP75_CONF_OS_COMP_INT 1
#define TMP75_CONF_OS_POL 2
#define TMP75_CONF_OS_F_QUE 3

// time in seconds
//#define SLEEP_TIME 60
#define SLEEP_TIME 600
#define FAST_SLEEP_TIME 10


#define GARAGE 1

// ADC caluibration
#ifdef GARAGE  
  #define CALIB_CODE 0x2AA
  #define CALIB_VOLTAGE 2.78
#else
  #define CALIB_CODE 0x2ee
  #define CALIB_VOLTAGE 3.06
#endif


const char* ssid = "xxxxxx";
const char* password = "xxxxxxxx";
const int channel = 1;
const uint8_t bssid[] = {0xC8, 0x60, 0x00, 0x94, 0x9B, 0x12};
#ifdef GARAGE  
IPAddress ip(192, 168, 0, 150);
#else
IPAddress ip(192, 168, 0, 151);
#endif
IPAddress gateway(192, 168, 0, 1);
IPAddress subnet(255, 255, 255, 0);
//IPAddress dns(1,1,1,1);
IPAddress dns(192,168,0,1);

// We make a structure to store connection information 
// The ESP8266 RTC memory is arranged into blocks of 4 bytes. The access methods read and write 4 bytes at a time,
// so the RTC data structure should be padded to a 4-byte multiple.
struct
{
  uint32_t crc32;   // 4 bytes
  uint8_t channel;  // 1 byte,   5 in total
  uint8_t ap_mac[6];// 6 bytes, 11 in total
  uint8_t padding;  // 1 byte,  12 in total
} rtcData;


const char* mqtt_broker = "192.168.0.253";
const int mqtt_port = 1883;
const char* mqtt_username = "homeassistant";
const char* mqtt_password = "quo8gaelai6zah4uthaefaer4theilai0oth0Cai0phoopahShungie5ohs4Chee";  
  

#ifdef GARAGE  
const char *topic[]  = {"garage/sensor/temperature/inside",
                        "garage/sensor/temperature/outside",
                        "garage/sensor/battery_level"};
#else
const char *topic[]  = {"workshop/sensor/temperature/inside",
                        "workshop/sensor/temperature/boiler",
                        "workshop/sensor/battery_level"};

#endif


WiFiClient wifiClient;
MqttClient mqttClient(wifiClient);

//uint8_t ds_address[] = {0x28, 0x69, 0xD8, 0x13, 0x00, 0x00, 0x00, 0x9B};
#ifdef GARAGE  
uint8_t ds_address[] = {0x28, 0x13, 0xec, 0x13, 0x00, 0x00, 0x00, 0x57};
#else
uint8_t ds_address[] = {0x28, 0x69, 0xD8, 0x13, 0x00, 0x00, 0x00, 0x9B};
#endif

void TMP75_ctrl(uint8_t ctrl)
{
  Wire.begin();                      // Join the I2C bus as a master 
  Wire.beginTransmission(TMP75_ADDRESS);       // Address the TMP75 sensor
  Wire.write(TMP75_CONF_REGISTER);                       // Address the Configuration register 
  Wire.write(ctrl);                         // Set the temperature resolution 
  Wire.endTransmission();                      // Stop transmitting
}

float readTemp()
{
  uint16_t regdata = 0xFFFF;
  TMP75_ctrl(0xA1); // One-Shot
  Wire.beginTransmission(TMP75_ADDRESS);
  Wire.write(TMP75_TEMP_REGISTER); // pointer reg
  Wire.endTransmission();
  Wire.requestFrom(TMP75_ADDRESS, 2);
  regdata = Wire.read();
  regdata <<= 8;
  regdata |= ((uint16_t)Wire.read());
  return ((float)(int16_t)regdata / 32) / 8;
}




void reset_RTC_counter(void)
{
  uint32_t bootcount =0;
  ESP.rtcUserMemoryWrite(0, &bootcount, sizeof(bootcount));  
}

uint16_t RTC_bootcount(void)
{
  uint32_t bootcount;
  uint16_t low_word; 
  uint16_t high_word; 
  uint16_t return_word; 
  ESP.rtcUserMemoryRead(0, &bootcount, sizeof(bootcount)); 
  low_word = bootcount & 0xFFFF;
  high_word = (bootcount>>16) & 0xFFFF;
  if (low_word!=high_word)
  {
    low_word = 0;
    high_word = 0;
  }
  return_word =  low_word;
  low_word++;
  high_word++;
  bootcount = (high_word << 16) + low_word;
  ESP.rtcUserMemoryWrite(0, &bootcount, sizeof(bootcount));
  return (return_word);
}

void SaveFloatRtc(float fnum1, float fnum2)
{
  union
  {
    uint32_t ltemp;  
    float ftemp;
  };
  ftemp = fnum1;
  ESP.rtcUserMemoryWrite(1, & ltemp, sizeof(ltemp));
  ftemp = fnum2;
  ESP.rtcUserMemoryWrite(2, & ltemp, sizeof(ltemp));
}

float GetFloatFromRtc(uint8_t offset)
{
  union
  {
    uint32_t ltemp;  
    float ftemp;
  };  
  ESP.rtcUserMemoryRead(offset+1, & ltemp, sizeof(ltemp)); 
  return ftemp;
}

uint32_t calculateCRC32( const uint8_t *data, size_t length )
{
  uint32_t crc = 0xffffffff;
  while( length-- ) 
  {
    uint8_t c = *data++;
    for( uint32_t i = 0x80; i > 0; i >>= 1 ) 
    {
      bool bit = crc & 0x80000000;
      if(c & i) bit = !bit;
      crc <<= 1;
      if(bit) crc ^= 0x04c11db7;
    }
  }
  return crc;
}


void setup_wifi() 
{

  // Try to read WiFi settings from RTC memory
  bool rtcValid = false;
  if( ESP.rtcUserMemoryRead( 3, (uint32_t*)&rtcData, sizeof( rtcData ) ) )
  {
    // Calculate the CRC of what we just read from RTC memory, but skip the first 4 bytes as that's the checksum itself.
    uint32_t crc = calculateCRC32( ((uint8_t*)&rtcData) + 4, sizeof( rtcData ) - 4 );
    if(crc == rtcData.crc32) rtcValid = true;
  }

  if (rtcValid) { Serial.print("WiFi settings ok"); }
  else { Serial.print("WiFi settings fail"); }
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.persistent(false);
  WiFi.mode(WIFI_STA);
  WiFi.config(ip, gateway, subnet, dns);

  if(rtcValid)  WiFi.begin( ssid, password, rtcData.channel, rtcData.ap_mac, true );
  else WiFi.begin(ssid, password);

  uint8_t trial_counter=10;
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(500);
    Serial.print(".");
    trial_counter--;
    if (trial_counter==0)
    {
      Serial.println();
      Serial.println("WiFi not availale");
      Serial.println("Deep sleep");
      rtcData.crc32++;  // now crc is wrong
      ESP.rtcUserMemoryWrite( 3, (uint32_t*)&rtcData, sizeof( rtcData ) );
      //reset_RTC_counter();
      ESP.deepSleep(SLEEP_TIME*1000000);        
    }
  }

  if (!rtcValid) 
  {
    // Write current connection info back to RTC
    rtcData.channel = WiFi.channel();
    memcpy(rtcData.ap_mac, WiFi.BSSID(), 6); // Copy 6 bytes of BSSID (AP's MAC address)
    rtcData.crc32 = calculateCRC32( ((uint8_t*)&rtcData) + 4, sizeof( rtcData ) - 4 );
    ESP.rtcUserMemoryWrite( 3, (uint32_t*)&rtcData, sizeof(rtcData));
  }

  Serial.println();
  Serial.println("WiFi connected");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());  
  Serial.print("nWiFi channel: ");
  Serial.println(WiFi.channel());
  Serial.print("WiFi BSSID: ");
  Serial.println(WiFi.BSSIDstr().c_str());
}



#define ONE_WIRE_GPIO 12
//DS18B20 ds(D6);   //	GPI12
DS18B20 ds(ONE_WIRE_GPIO); 


void setup()
{
  float SensValues[3];
  bool TimeToUpdate = false;
  Serial.begin(115200);
  delay(100);
  Serial.println();

  uint16_t boot_counter;
  boot_counter = RTC_bootcount();

  Serial.println();
  Serial.print("Boot count ");
  Serial.println(boot_counter);

  Wire.begin();  
  Wire.setClock(400000);
  //TMP75_ctrl(0x01); // SD mode 0.5C
  TMP75_ctrl(0x21); // SD mode 0.25C

  float prevT0 = GetFloatFromRtc(0);
  float prevT1 = GetFloatFromRtc(1);


  Serial.print("T©=");
  // check TMP75
  SensValues[0] = readTemp();  
  Serial.print(SensValues[0]);
  Serial.print(", ");
  // check DS18B20
  if (ds.select(ds_address)) SensValues[1] = ds.getTempC();
  else Serial.println("DS18B20 not found!");
  Serial.println(SensValues[1]);

  if(abs(prevT0-SensValues[0])>0.5) TimeToUpdate = true;
  if(abs(prevT1-SensValues[1])>0.5) TimeToUpdate = true;  

  if (boot_counter==0)
  {
    setup_wifi() ;
    delay(100);
    //uint16_t batterylevel = ESP.getVcc(); 


    pinMode(14, OUTPUT);
    digitalWrite(14, HIGH);
    uint16_t batterylevel = analogRead(A0);
    Serial.print("ADC=0x");
    Serial.print(batterylevel, HEX);        
    SensValues[2] = (float)batterylevel/CALIB_CODE*CALIB_VOLTAGE;
    Serial.print(", V=");  
    Serial.println(SensValues[2]);
    
    mqttClient.setUsernamePassword(mqtt_username, mqtt_password);
    if (mqttClient.connect(mqtt_broker)) 
    {
      Serial.println("You're connected to the MQTT broker!");
      for(uint8_t i=0; i<3; i++)
      {
        mqttClient.beginMessage(topic[i]);
        mqttClient.print(SensValues[i]);
        mqttClient.endMessage();
        delay(10);
      }
      SaveFloatRtc(SensValues[0], SensValues[1]);
      mqttClient.poll();
      TimeToUpdate = false;
      delay(500);
    }
    else
    {
      Serial.print("MQTT connection failed! Error code = ");
      Serial.println(mqttClient.connectError());
    }
  }

  Serial.println("Deep sleep mode");
  if (TimeToUpdate)  
  {
    reset_RTC_counter();
    ESP.deepSleep(FAST_SLEEP_TIME*1000000);  //uS
  }
  else
  {
    if (boot_counter>=5)
    {
      reset_RTC_counter();
      ESP.deepSleep(SLEEP_TIME*1000000);  
    }
    else ESP.deepSleep(SLEEP_TIME*1000000, WAKE_RF_DISABLED);  // WAKE_RF_DISABLED
  }
}


void loop() {}