PlantCtrl/esp32/src/main.cpp

659 lines
18 KiB
C++
Raw Normal View History

2020-11-06 22:19:16 +01:00
/** \addtogroup Controller
* @{
*
2020-09-07 18:18:46 +02:00
* @file main.cpp
* @author Ollo
* @brief PlantControl
* @version 0.1
* @date 2020-05-01
*
* @copyright Copyright (c) 2020
*/
2020-12-21 16:12:46 +01:00
/******************************************************************************
* INCLUDES
******************************************************************************/
2020-09-07 18:18:46 +02:00
#include "PlantCtrl.h"
#include "ControllerConfiguration.h"
2020-10-16 16:22:48 +02:00
#include "HomieConfiguration.h"
#include "DallasTemperature.h"
2020-09-07 18:18:46 +02:00
#include <Homie.h>
2020-10-19 01:39:56 +02:00
#include "time.h"
#include "esp_sleep.h"
2020-10-16 19:26:05 +02:00
#include "RunningMedian.h"
2020-11-28 01:45:57 +01:00
#include "WakeReason.h"
#include <stdint.h>
2020-11-06 21:00:11 +01:00
#include <math.h>
#include <OneWire.h>
#include "DS2438.h"
2020-09-07 18:18:46 +02:00
2020-12-21 16:12:46 +01:00
/******************************************************************************
* DEFINES
******************************************************************************/
#define AMOUNT_SENOR_QUERYS 8
2020-11-06 19:15:43 +01:00
2020-12-21 16:12:46 +01:00
/******************************************************************************
* FUNCTION PROTOTYPES
******************************************************************************/
int determineNextPump();
//void setLastActivationForPump(int pumpId, long time);
2020-12-28 14:57:17 +01:00
int readTemp();
2020-12-21 16:12:46 +01:00
/******************************************************************************
* NON VOLATILE VARIABLES in DEEP SLEEP
******************************************************************************/
//only relevant if mode2 did start pumping before
2020-11-06 21:00:11 +01:00
RTC_DATA_ATTR int lastPumpRunning = 0;
RTC_DATA_ATTR long lastWaterValue = 0;
2020-11-06 21:00:11 +01:00
RTC_DATA_ATTR int gBootCount = 0;
//FIXME use -1 and configure properly
RTC_DATA_ATTR int rtcLipoTempIndex = 0;
RTC_DATA_ATTR int rtcWaterTempIndex = -1;
2020-10-19 01:39:56 +02:00
2020-12-21 16:12:46 +01:00
/******************************************************************************
* LOCAL VARIABLES
******************************************************************************/
bool volatile mode3Active = false; /**< Controller must not sleep */
2020-10-31 03:51:35 +01:00
bool volatile mDeepsleep = false;
2020-10-16 19:26:05 +02:00
2020-09-07 18:18:46 +02:00
int readCounter = 0;
2020-09-21 20:42:24 +02:00
bool mConfigured = false;
long nextBlink = 0; /**< Time needed in main loop to support expected blink code */
2020-09-07 18:18:46 +02:00
2020-10-16 19:26:05 +02:00
RunningMedian waterRawSensor = RunningMedian(5);
float mTempLipo = 0.0f;
float mTempWater = 0.0f;
2021-02-16 22:25:12 +01:00
float mBatteryVoltage = 0.0f;
float mSolarVoltage = 0.0f;
float mChipTemp = 0.0f;
/*************************** Hardware abstraction *****************************/
2020-10-16 19:26:05 +02:00
OneWire oneWire(SENSOR_DS18B20);
DallasTemperature sensors(&oneWire);
DS2438 battery(&oneWire, 0.1f);
2020-09-07 18:18:46 +02:00
Plant mPlants[MAX_PLANTS] = {
Plant(SENSOR_PLANT0, OUTPUT_PUMP0, 0, &plant0, &mSetting0),
Plant(SENSOR_PLANT1, OUTPUT_PUMP1, 1, &plant1, &mSetting1),
Plant(SENSOR_PLANT2, OUTPUT_PUMP2, 2, &plant2, &mSetting2),
Plant(SENSOR_PLANT3, OUTPUT_PUMP3, 3, &plant3, &mSetting3),
Plant(SENSOR_PLANT4, OUTPUT_PUMP4, 4, &plant4, &mSetting4),
Plant(SENSOR_PLANT5, OUTPUT_PUMP5, 5, &plant5, &mSetting5),
Plant(SENSOR_PLANT6, OUTPUT_PUMP6, 6, &plant6, &mSetting6)};
2020-12-21 16:12:46 +01:00
/******************************************************************************
* LOCAL FUNCTIONS
******************************************************************************/
long getDistance()
{
byte startByte, h_data, l_data, sum;
2020-11-18 22:11:37 +01:00
byte buf[3];
2020-11-18 22:11:37 +01:00
startByte = (byte)Serial.read();
if (startByte == 255)
{
unsigned int distance;
2020-11-18 22:11:37 +01:00
Serial.readBytes(buf, 3);
h_data = buf[0];
l_data = buf[1];
sum = buf[2];
distance = (h_data << 8) + l_data;
if (((startByte + h_data + l_data) & 0xFF) != sum)
{
2020-11-18 22:11:37 +01:00
return -1;
}
else
{
2020-11-18 22:11:37 +01:00
return distance;
}
}
else
{
2020-11-18 22:11:37 +01:00
return -2;
}
}
long getCurrentTime()
{
2020-10-21 19:50:05 +02:00
struct timeval tv_now;
gettimeofday(&tv_now, NULL);
return tv_now.tv_sec;
2020-10-20 18:06:37 +02:00
}
void espDeepSleepFor(long seconds, bool activatePump = false)
{
if (mode3Active)
{
Serial << "abort deepsleep, mode3Active" << endl;
2020-10-31 03:51:35 +01:00
return;
}
for (int i = 0; i < 10; i++)
{
long cTime = getCurrentTime();
if (cTime < 100000)
{
Serial << "Wait for ntp" << endl;
delay(100);
}
else
{
break;
}
}
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_SLOW_MEM, ESP_PD_OPTION_ON);
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_FAST_MEM, ESP_PD_OPTION_ON);
if (activatePump)
{
esp_sleep_pd_config(ESP_PD_DOMAIN_XTAL, ESP_PD_OPTION_ON);
gpio_deep_sleep_hold_en();
2020-10-23 16:47:40 +02:00
gpio_hold_en(GPIO_NUM_13); //pump pwr
}
else
{
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_FAST_MEM, ESP_PD_OPTION_OFF);
gpio_hold_dis(GPIO_NUM_13); //pump pwr
2020-10-28 20:14:52 +01:00
gpio_deep_sleep_hold_dis();
digitalWrite(OUTPUT_PUMP, LOW);
digitalWrite(OUTPUT_SENSOR, LOW);
for (int i = 0; i < MAX_PLANTS; i++)
{
mPlants[i].deactivatePump();
}
2020-10-23 16:47:40 +02:00
}
2020-10-21 20:46:09 +02:00
//gpio_hold_en(GPIO_NUM_23); //p0
//FIXME fix for outher outputs
Serial.print("Trying to sleep for ");
2020-10-21 19:50:05 +02:00
Serial.print(seconds);
Serial.println(" seconds");
esp_sleep_enable_timer_wakeup((seconds * 1000U * 1000U));
mDeepsleep = true;
2020-10-21 19:50:05 +02:00
}
void mode2MQTT()
{
2020-10-21 19:50:05 +02:00
digitalWrite(OUTPUT_PUMP, LOW);
for (int i = 0; i < MAX_PLANTS; i++)
{
2020-10-23 16:20:34 +02:00
mPlants[i].deactivatePump();
2020-10-21 19:50:05 +02:00
}
if (lastPumpRunning != -1)
{
//long waterDiff = waterRawSensor.getAverage() - lastWaterValue;
2020-10-20 18:06:37 +02:00
//TODO attribute used water in ml to plantid
}
for (int i = 0; i < MAX_PLANTS; i++)
{
long raw = mPlants[i].getCurrentMoisture();
long pct = 100 - map(raw, MOIST_SENSOR_MIN_ADC, MOIST_SENSOR_MAX_ADC, 0, 100);
if (raw == MISSING_SENSOR)
{
pct = 0;
}
if (pct < 0)
{
pct = 0;
}
if (pct > 100)
{
pct = 100;
}
mPlants[i].setProperty("moist").send(String(pct));
mPlants[i].setProperty("moistraw").send(String(raw));
2020-10-21 20:46:09 +02:00
}
2020-11-11 21:33:11 +01:00
sensorWater.setProperty("remaining").send(String(waterLevelMax.get() - waterRawSensor.getAverage()));
Serial << "W : " << waterRawSensor.getAverage() << " cm (" << String(waterLevelMax.get() - waterRawSensor.getAverage()) << "%)" << endl;
2020-11-11 21:28:03 +01:00
lastWaterValue = waterRawSensor.getAverage();
2020-10-20 18:06:37 +02:00
sensorLipo.setProperty("percent").send(String(100 * mBatteryVoltage / VOLT_MAX_BATT));
2021-02-16 22:25:12 +01:00
sensorLipo.setProperty("volt").send(String(mBatteryVoltage));
sensorLipo.setProperty("current").send(String(battery.getCurrent()));
2021-02-16 23:40:05 +01:00
sensorLipo.setProperty("Ah").send(String(battery.getAh()));
sensorLipo.setProperty("ICA").send(String(battery.getICA()));
sensorLipo.setProperty("DCA").send(String(battery.getDCA()));
sensorLipo.setProperty("CCA").send(String(battery.getCCA()));
2021-02-16 22:25:12 +01:00
sensorSolar.setProperty("volt").send(String(mSolarVoltage));
2020-10-20 18:06:37 +02:00
rtcLipoTempIndex = lipoSensorIndex.get();
rtcWaterTempIndex = waterSensorIndex.get();
sensorTemp.setProperty(TEMPERATUR_SENSOR_LIPO).send(String(mTempLipo));
Serial << "Lipo Temperatur " << mTempLipo << " °C " << endl;
2021-02-16 22:29:07 +01:00
sensorTemp.setProperty(TEMPERATUR_SENSOR_WATER).send(String(mTempWater));
Serial << "Water Temperatur " << mTempWater << " °C " << endl;
2020-12-28 14:57:17 +01:00
sensorTemp.setProperty(TEMPERATUR_SENSOR_CHIP).send(String(mChipTemp));
Serial << "Chip Temperatur " << mChipTemp << " °C " << endl;
2020-10-20 18:06:37 +02:00
bool hasWater = true; //FIXMEmWaterGone > waterLevelMin.get();
2020-10-21 19:50:05 +02:00
//FIXME no water warning message
2020-10-20 18:06:37 +02:00
lastPumpRunning = determineNextPump();
if (lastPumpRunning != -1 && !hasWater)
{
2020-10-21 20:46:09 +02:00
Serial.println("Want to pump but no water");
}
if (lastPumpRunning != -1 && hasWater)
{
2020-11-04 22:12:00 +01:00
if (mode3Active)
{
Serial.println("Mode 3 active, ignoring pump request");
}
else
{
digitalWrite(OUTPUT_PUMP, HIGH);
//TODO setLastActivationForPump(lastPumpRunning, getCurrentTime());
2020-11-04 22:12:00 +01:00
mPlants[lastPumpRunning].activatePump();
}
2020-10-20 18:06:37 +02:00
}
if (lastPumpRunning == -1 || !hasWater)
{
2021-02-16 22:25:12 +01:00
if (mSolarVoltage < SOLAR_CHARGE_MIN_VOLTAGE)
{
2021-02-16 22:25:12 +01:00
Serial.print(mSolarVoltage);
Serial.println("V! No pumps to activate and low light, deepSleepNight");
2020-10-21 19:50:05 +02:00
espDeepSleepFor(deepSleepNightTime.get());
}
else
{
2020-10-21 19:50:05 +02:00
Serial.println("No pumps to activate, deepSleep");
espDeepSleepFor(deepSleepTime.get());
}
}
else
{
2020-10-21 19:50:05 +02:00
Serial.println("Running pump, watering deepsleep");
2020-10-23 16:47:40 +02:00
espDeepSleepFor(wateringDeepSleep.get(), true);
2020-10-21 19:50:05 +02:00
}
2020-10-20 18:06:37 +02:00
}
2020-12-21 16:18:22 +01:00
/**
* @brief Read ultra sensor JSN-SR04T-2.0
* Read the distance of the water level.
*/
void readDistance()
{
for (int i = 0; i < 5; i++)
{
long start = millis();
while (!Serial.available())
{
if ((start + 500) < millis())
{
Serial << "Abort reading hall sensor, not measurement after 200ms" << endl;
waterRawSensor.add(0);
return;
}
}
unsigned int distance = getDistance();
if (distance > 0)
{
waterRawSensor.add(distance);
}
}
}
2020-10-16 19:26:05 +02:00
/**
* @brief Sensors, that are connected to GPIOs, mandatory for WIFI.
* These sensors (ADC2) can only be read when no Wifi is used.
*/
void readSensors()
{
Serial << "Read Sensors" << endl;
/* activate all sensors */
2020-10-16 19:26:05 +02:00
digitalWrite(OUTPUT_SENSOR, HIGH);
/* wait before reading something */
delay(20);
int timeoutTemp = millis() + TEMPERATUR_TIMEOUT;
int sensorCount = 0;
/* Required to read the temperature at least once */
while ((sensorCount == 0 || !battery.isFound()) && millis() < timeoutTemp)
{
sensors.begin();
battery.begin();
sensorCount = sensors.getDS18Count();
delay(50);
2020-10-16 19:26:05 +02:00
}
Serial << "One wire count: " << sensorCount << " found in " << (millis() - timeoutTemp) << "ms" << endl;
/* Measure temperature */
if (sensorCount > 0)
{
sensors.requestTemperatures();
}
2020-10-16 19:26:05 +02:00
for (int i = 0; i < sensorCount; i++) {
float temp = sensors.getTempCByIndex(i);
Serial << "OneWire sensor " << i << " has value " << temp << endl;
if (rtcWaterTempIndex != -1 && rtcWaterTempIndex == i) {
mTempWater = temp;
}
if (rtcLipoTempIndex != -1 && rtcLipoTempIndex == i) {
mTempLipo = temp;
}
}
// Update battery chip data
battery.update();
mSolarVoltage = battery.getVoltage(BATTSENSOR_INDEX_SOLAR) * SOLAR_VOLT_FACTOR;
mBatteryVoltage = battery.getVoltage(BATTSENSOR_INDEX_BATTERY);
mChipTemp = battery.getTemperature();
// if(mBatteryVoltage < MINIMUM_LIPO_VOLT){
// Serial.println("Low lipo voltage, abort high level processing");
// }
for (int readCnt = 0; readCnt < AMOUNT_SENOR_QUERYS; readCnt++)
{
for (int i = 0; i < MAX_PLANTS; i++)
{
mPlants[i].addSenseValue();
}
delay(10);
}
/* Read the distance and give the temperature sensors some time */
readDistance();
Serial << "Distance sensor " << waterRawSensor.getAverage() << " cm" << endl;
2020-11-06 21:00:11 +01:00
2020-10-16 19:26:05 +02:00
/* deactivate the sensors */
digitalWrite(OUTPUT_SENSOR, LOW);
2020-09-07 18:18:46 +02:00
}
void onHomieEvent(const HomieEvent &event)
{
switch (event.type)
{
case HomieEventType::SENDING_STATISTICS:
Homie.getLogger() << "My statistics" << endl;
break;
case HomieEventType::MQTT_READY:
Serial.printf("NTP Setup with server %s\r\n", ntpServer.get());
configTime(0, 0, ntpServer.get());
Serial << "Setup plants" << endl;
for (int i = 0; i < MAX_PLANTS; i++)
{
mPlants[i].postMQTTconnection();
}
mode2MQTT();
break;
case HomieEventType::OTA_STARTED:
Homie.getLogger() << "OTA started" << endl;
digitalWrite(OUTPUT_SENSOR, HIGH);
digitalWrite(OUTPUT_PUMP, HIGH);
gpio_hold_dis(GPIO_NUM_13); //pump pwr
gpio_deep_sleep_hold_dis();
for (int i = 0; i < MAX_PLANTS; i++)
{
mPlants[i].deactivatePump();
}
mode3Active = true;
break;
case HomieEventType::OTA_SUCCESSFUL:
Homie.getLogger() << "OTA successfull" << endl;
digitalWrite(OUTPUT_SENSOR, LOW);
digitalWrite(OUTPUT_PUMP, LOW);
ESP.restart();
break;
default:
break;
2020-09-07 18:18:46 +02:00
}
2020-10-19 01:39:56 +02:00
}
2020-09-07 18:18:46 +02:00
int determineNextPump()
{
2021-02-16 22:25:12 +01:00
bool isLowLight = (mSolarVoltage > SOLAR_CHARGE_MIN_VOLTAGE || mSolarVoltage < SOLAR_CHARGE_MAX_VOLTAGE);
2020-10-19 01:39:56 +02:00
//FIXME instead of for, use sorted by last activation index to ensure equal runtime?
int pumpToUse = -1;
for (int i = 0; i < MAX_PLANTS; i++)
{
Plant plant = mPlants[i];
//TODO skip pump last used here!
//if (plant.isInCooldown(sinceLastActivation))
//{
// Serial.printf("%d Skipping due to cooldown %ld / %ld \r\n", i, sinceLastActivation, plant.getCooldownInSeconds());
//continue;
//}
2020-10-19 01:39:56 +02:00
//skip as it is not low light
if (!isLowLight && plant.isAllowedOnlyAtLowLight())
{
Serial.printf("%d No pump required: due to light\r\n", i);
2020-10-19 01:39:56 +02:00
continue;
}
2020-11-06 21:00:11 +01:00
if (plant.getCurrentMoisture() == MISSING_SENSOR && plant.isPumpTriggerActive())
{
Serial.printf("%d No pump possible: missing sensor \r\n", i);
continue;
}
if (plant.isPumpRequired())
{
2020-10-23 16:32:05 +02:00
Serial.printf("%d Requested pumping\r\n", i);
pumpToUse = i;
}
else if (plant.isPumpTriggerActive())
{
Serial.printf("%d No pump required: moisture acceptable %f / %ld\r\n", i, plant.getCurrentMoisture(), plant.getSettingsMoisture());
}
else
{
Serial.printf("%d No pump required: disabled pump trigger \r\n", i);
2020-09-07 18:18:46 +02:00
}
}
return pumpToUse;
2020-10-19 01:39:56 +02:00
}
2020-09-07 18:18:46 +02:00
2020-10-13 20:16:28 +02:00
/**
* @brief Handle Mqtt commands to keep controller alive
*
* @param range multiple transmitted values (not used for this function)
* @param value single value
* @return true when the command was parsed and executed succuessfully
* @return false on errors when parsing the request
*/
bool aliveHandler(const HomieRange &range, const String &value)
{
if (range.isRange)
return false; // only one controller is present
if (value.equals("ON") || value.equals("On") || value.equals("1"))
{
mode3Active = true;
}
else
{
mode3Active = false;
}
2020-10-13 20:16:28 +02:00
return true;
}
void homieLoop()
{
2020-10-20 20:12:27 +02:00
}
void systemInit()
{
2020-10-16 20:36:07 +02:00
WiFi.mode(WIFI_STA);
Homie_setFirmware("PlantControl", FIRMWARE_VERSION);
2020-09-07 18:18:46 +02:00
2020-10-16 20:36:07 +02:00
// Set default values
2020-10-21 19:50:05 +02:00
//in seconds
maxTimeBetweenMQTTUpdates.setDefaultValue(700);
deepSleepTime.setDefaultValue(600);
2020-10-31 12:44:49 +01:00
deepSleepNightTime.setDefaultValue(600);
2020-10-21 19:50:05 +02:00
wateringDeepSleep.setDefaultValue(5);
ntpServer.setDefaultValue("pool.ntp.org");
2020-10-21 19:50:05 +02:00
/* waterLevelMax 1000 */ /* 100cm in mm */
waterLevelMin.setDefaultValue(50); /* 5cm in mm */
waterLevelWarn.setDefaultValue(500); /* 50cm in mm */
waterLevelVol.setDefaultValue(5000); /* 5l in ml */
lipoSensorIndex.setDefaultValue(0);
waterSensorIndex.setDefaultValue(-1);
2020-10-20 20:12:27 +02:00
Homie.setLoopFunction(homieLoop);
2020-10-21 18:14:51 +02:00
Homie.onEvent(onHomieEvent);
//Homie.disableLogging();
2020-10-20 20:12:27 +02:00
Homie.setup();
2020-10-16 21:50:42 +02:00
mConfigured = Homie.isConfigured();
if (mConfigured)
{
for (int i = 0; i < MAX_PLANTS; i++)
{
2020-10-23 16:20:34 +02:00
mPlants[i].advertise();
}
2020-12-21 17:07:15 +01:00
sensorTemp.advertise(TEMPERATUR_SENSOR_LIPO)
.setName(TEMPERATURE_NAME)
.setDatatype(NUMBER_TYPE)
.setUnit(TEMPERATURE_UNIT);
sensorTemp.advertise(TEMPERATUR_SENSOR_WATER)
.setName(TEMPERATURE_NAME)
.setDatatype(NUMBER_TYPE)
.setUnit(TEMPERATURE_UNIT);
2021-02-16 22:29:07 +01:00
sensorTemp.advertise(TEMPERATUR_SENSOR_CHIP)
.setName(TEMPERATURE_NAME)
.setDatatype(NUMBER_TYPE)
.setUnit(TEMPERATURE_UNIT);
2020-09-21 20:42:24 +02:00
sensorLipo.advertise("percent")
.setName("Percent")
2020-12-21 17:07:15 +01:00
.setDatatype(NUMBER_TYPE)
.setUnit("%");
2020-09-21 20:42:24 +02:00
sensorLipo.advertise("volt")
.setName("Volt")
2020-12-21 17:07:15 +01:00
.setDatatype(NUMBER_TYPE)
.setUnit("V");
2020-09-21 20:42:24 +02:00
sensorSolar.advertise("percent")
.setName("Percent")
2020-12-21 17:07:15 +01:00
.setDatatype(NUMBER_TYPE)
.setUnit("%");
2020-09-21 20:42:24 +02:00
sensorSolar.advertise("volt")
.setName("Volt")
2020-12-21 17:07:15 +01:00
.setDatatype(NUMBER_TYPE)
.setUnit("V");
2020-12-21 17:07:15 +01:00
sensorWater.advertise("remaining").setDatatype(NUMBER_TYPE).setUnit("%");
startupReason.advertise("startupReason").setDatatype(NUMBER_TYPE).setUnit("Enum");
2020-09-21 20:42:24 +02:00
}
2020-12-21 17:07:15 +01:00
stayAlive.advertise("alive").setName("Alive").setDatatype(NUMBER_TYPE).settable(aliveHandler);
2020-10-16 19:26:05 +02:00
}
void mode2()
{
2020-10-31 12:44:49 +01:00
Serial.println("==== Mode 2 ====");
2020-10-16 20:36:07 +02:00
systemInit();
/* Jump into Mode 3, if not configured */
if (!mConfigured)
{
Serial.println("==== Mode 3 ====");
2020-10-16 20:36:07 +02:00
mode3Active = true;
}
2020-10-16 19:26:05 +02:00
}
/**
* @brief Startup function
* Is called once, the controller is started
*/
void setup()
{
2021-02-16 23:40:05 +01:00
Serial.begin(115200);
Serial << endl
<< endl;
2020-10-16 19:26:05 +02:00
/* Intialize Plant */
for (int i = 0; i < MAX_PLANTS; i++)
{
2020-10-16 19:26:05 +02:00
mPlants[i].init();
}
2020-09-07 18:18:46 +02:00
// read button
2020-10-16 19:26:05 +02:00
pinMode(BUTTON, INPUT);
2020-10-23 16:20:34 +02:00
// Power pins
2020-10-21 20:51:25 +02:00
pinMode(OUTPUT_PUMP, OUTPUT);
pinMode(OUTPUT_SENSOR, OUTPUT);
// Individual Pump pins
2020-10-16 19:26:05 +02:00
/* Disable Wifi and bluetooth */
WiFi.mode(WIFI_OFF);
2020-09-07 18:18:46 +02:00
if (HomieInternals::MAX_CONFIG_SETTING_SIZE < MAX_CONFIG_SETTING_ITEMS)
{
//increase the config settings to 50 and the json to 3000
Serial << "Limits.hpp" << endl;
2020-10-16 19:26:05 +02:00
}
readSensors();
2020-10-16 20:36:07 +02:00
// Big TODO use here the settings in RTC_Memory
2020-09-07 18:18:46 +02:00
2020-10-21 18:33:38 +02:00
//Panik mode, the Lipo is empty, sleep a long long time:
// if ((mBatteryVoltage < MINIMUM_LIPO_VOLT) &&
// (mBatteryVoltage > NO_LIPO_VOLT))
// {
// Serial << PANIK_MODE_DEEPSLEEP << " s lipo " << mBatteryVoltage << "V" << endl;
// esp_sleep_enable_timer_wakeup(PANIK_MODE_DEEPSLEEP_US);
// esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
// esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_FAST_MEM, ESP_PD_OPTION_OFF);
// esp_sleep_pd_config(ESP_PD_DOMAIN_XTAL, ESP_PD_OPTION_ON);
// esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_SLOW_MEM, ESP_PD_OPTION_OFF);
// esp_deep_sleep_start();
// }
mode2();
2020-09-07 18:18:46 +02:00
}
/**
* @brief Cyclic call
* Executs the Homie base functionallity or triggers sleeping, if requested.
*/
void loop()
{
/* Toggel Senor LED to visualize mode 3 */
if (mode3Active)
{
if (nextBlink < millis())
{
nextBlink = millis() + 500;
digitalWrite(OUTPUT_SENSOR, !digitalRead(OUTPUT_SENSOR));
}
}
else if (!mDeepsleep)
{
Homie.loop();
}
else
{
Serial << "Bye" << endl;
Serial.flush();
esp_deep_sleep_start();
}
2020-10-16 20:36:07 +02:00
if (millis() > 30000 && !mode3Active)
{
Serial << (millis() / 1000) << "not terminated watchdog reset" << endl;
2020-10-16 20:36:07 +02:00
Serial.flush();
esp_restart();
2020-11-01 20:42:45 +01:00
}
2020-09-07 18:18:46 +02:00
}
2020-11-06 22:19:16 +01:00
2020-11-29 05:04:46 +01:00
/** @}*/