Merge branch 'master' into noprints

# Conflicts:
#	src/Heating.cpp
#	src/main.cpp

.gitlab-ci.yml

@@ -6,6 +6,7 @@ stages:
 cache:
   paths:
     - "~/.platformio"
+    - ./interface/node_modules
 
 before_script:
   - "pip install -U platformio"
@@ -13,7 +14,10 @@ before_script:
 
 build:
   stage: build
-  script: "platformio run -e esp12e"
+  script:
+    - "platformio run -e esp12e"
+    - vers=$(grep -Po '[0-9]+\.[0-9]+\.[0-9]+[-0-9A-Za-z]*(?=\")' ./src/Pins.h)
+    - mv .pio/build/esp12e/*.bin Pumpensteuerung-${vers}.bin
   artifacts:
     paths:
-      - .pio/build/esp12e/*.bin
+      - ./*.bin

factory_settings.ini

@@ -13,6 +13,7 @@ build_flags =
     -D FACTORY_AP_LOCAL_IP=\"192.168.4.1\"
     -D FACTORY_AP_GATEWAY_IP=\"192.168.4.1\"
     -D FACTORY_AP_SUBNET_MASK=\"255.255.255.0\"
+    -D FACTORY_AP_VISIBLE=true
 
     ; User credentials for admin and guest user
     -D FACTORY_ADMIN_USERNAME=\"admin\"

interface/build/app/manifest.json

@@ -1,12 +0,0 @@
-{
-  "name":"ESP8266 React",
-  "icons":[
-    {
-      "src":"/app/icon.png",
-      "sizes":"48x48 72x72 96x96 128x128 256x256"
-    }
-  ],
-  "start_url":"/",
-  "display":"fullscreen",
-  "orientation":"any"
-}

interface/build/css/roboto.css

@@ -1,22 +0,0 @@
-/* Just supporting latin due to size constrains on the esp chip */
-@font-face {
-  font-family: 'Roboto';
-  font-style: normal;
-  font-weight: 300;
-  src: local('Roboto Light'), local('Roboto-Light'), url(../fonts/li.woff2) format('woff2');
-  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2212, U+2215;
-}
-@font-face {
-  font-family: 'Roboto';
-  font-style: normal;
-  font-weight: 400;
-  src: local('Roboto'), local('Roboto-Regular'), url(../fonts/re.woff2) format('woff2');
-  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2212, U+2215;
-}
-@font-face {
-  font-family: 'Roboto';
-  font-style: normal;
-  font-weight: 500;
-  src: local('Roboto Medium'), local('Roboto-Medium'), url(../fonts/me.woff2) format('woff2');
-  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2212, U+2215;
-}

interface/src/ap/APSettingsForm.tsx

@@ -3,8 +3,9 @@ import { TextValidator, ValidatorForm, SelectValidator } from 'react-material-ui
 
 import MenuItem from '@material-ui/core/MenuItem';
 import SaveIcon from '@material-ui/icons/Save';
+import Checkbox from '@material-ui/core/Checkbox';
 
-import { PasswordValidator, RestFormProps, FormActions, FormButton } from '../components';
+import {PasswordValidator, RestFormProps, FormActions, FormButton, BlockFormControlLabel} from '../components';
 
 import { isAPEnabled } from './APModes';
 import { APSettings, APProvisionMode } from './types';
@@ -91,6 +92,16 @@ class APSettingsForm extends React.Component<APSettingsFormProps> {
               onChange={handleValueChange('subnet_mask')}
               margin="normal"
             />
+              <BlockFormControlLabel
+                  control={
+                      <Checkbox
+                          value="network_visible"
+                          checked={data.network_visible}
+                          onChange={handleValueChange("network_visible")}
+                      />
+                  }
+                  label="Network visible?"
+              />
           </Fragment>
         }
         <FormActions>

interface/src/ap/types.ts

@@ -24,4 +24,5 @@ export interface APSettings {
   local_ip: string;
   gateway_ip: string;
   subnet_mask: string;
+  network_visible: boolean;
 }

interface/src/project/GeneralInformation.tsx

@@ -1,15 +1,10 @@
 import React, {Component} from 'react';
 import {Box, List, ListItem, ListItemText} from '@material-ui/core';
-import {
-    FormButton,
-    restController,
-    RestControllerProps,
-    RestFormLoader,
-    SectionContent
-} from '../components';
+import {FormButton, restController, RestControllerProps, RestFormLoader, SectionContent} from '../components';
 import {ENDPOINT_ROOT} from "../api";
 import {GeneralInformaitonState} from "./types";
 import RefreshIcon from "@material-ui/icons/Refresh";
+import {getRealTimeString, stringifyTime} from "./Time";
 
 // define api endpoint
 export const GENERALINFORMATION_SETTINGS_ENDPOINT = ENDPOINT_ROOT + "generalinfo";
@@ -17,20 +12,8 @@ export const GENERALINFORMATION_SETTINGS_ENDPOINT = ENDPOINT_ROOT + "generalinfo
 type GeneralInformationRestControllerProps = RestControllerProps<GeneralInformaitonState>;
 
 class GeneralInformation extends Component<GeneralInformationRestControllerProps> {
-    intervalhandler: number | undefined;
-
     componentDidMount() {
         this.props.loadData();
-
-        // this.intervalhandler = window.setInterval(() => {
-        //     this.props.loadData();
-        //     console.log("refreshing data");
-        //     console.log(this.props.data)
-        // }, 10000);
-    }
-
-    componentWillUnmount() {
-        clearInterval(this.intervalhandler);
     }
 
     render() {
@@ -44,31 +27,40 @@ class GeneralInformation extends Component<GeneralInformationRestControllerProps
                                 <ListItem>
                                     <ListItemText
                                         primary="Chip läuft seit:"
-                                            secondary={this.stringifyTime(props.data.runtime)}
+                                        secondary={<>{stringifyTime(props.data.runtime)}
+                                            <br/> {getRealTimeString(props.data.runtime)}</>}
                                     />
                                 </ListItem>
                                 <ListItem>
                                     <ListItemText
                                         primary="Zuletzt zu wenig Wasser:"
-                                            secondary={props.data.lastWaterOutage !== 0 ? "vor " + this.stringifyTime(props.data.lastWaterOutage) : "noch nie!"}
+                                        secondary={props.data.lastWaterOutage !== 0 ?
+                                            <>
+                                                vor {stringifyTime(props.data.lastWaterOutage)}<br/>
+                                                {getRealTimeString(props.data.lastWaterOutage)}
+                                            </> : "noch nie!"}
                                     />
                                 </ListItem>
                                 <ListItem>
                                     <ListItemText
                                         primary="Letzer Pumpenzyklus"
-                                            secondary={props.data.lastpumptime !== 0 ? "vor " + this.stringifyTime(props.data.lastpumptime) : "noch nie!"}
+                                        secondary={props.data.lastpumptime !== 0 ?
+                                            <>
+                                                vor {stringifyTime(props.data.lastpumptime)}<br/>
+                                                {getRealTimeString(props.data.lastpumptime)}
+                                            </> : "noch nie!"}
                                     />
                                 </ListItem>
                                 <ListItem>
                                     <ListItemText
                                         primary="Letze Pumpdauer:"
-                                            secondary={props.data.lastPumpDuration !== 0 ? this.stringifyTime(props.data.lastPumpDuration) : "-"}
+                                        secondary={props.data.lastPumpDuration !== 0 ? stringifyTime(props.data.lastPumpDuration) : "-"}
                                     />
                                 </ListItem>
                                 <ListItem>
                                     <ListItemText
-                                            primary="Temperatur/Luftfeuchtigkeit:"
-                                            secondary={(props.data.temp !== -1 ? props.data.temp + "C" : "Auslesefehler!") + " / " + (props.data.hum !== -1 ? props.data.hum + "%" : "Auslesefehler!")}
+                                        primary="Pumpzyklen seit Programmstart"
+                                        secondary={props.data.pumpcycles}
                                     />
                                 </ListItem>
                                 <ListItem>
@@ -95,26 +87,6 @@ class GeneralInformation extends Component<GeneralInformationRestControllerProps
             </SectionContent>
         );
     }
-
-    /**
-     * stringify seconds to a pretty format
-     * @param sec number of seconds
-     */
-    stringifyTime(sec: number): string {
-        if (sec >= 86400) {
-            // display days
-            return (Math.trunc(sec / 86400) + "d " + Math.trunc((sec % 86400) / 3600) + "h " + Math.trunc((sec % 3600) / 60) + "min " + sec % 60 + "sec");
-        } else if (sec >= 3600) {
-            // display hours
-            return (Math.trunc(sec / 3600) + "h " + Math.trunc((sec % 3600) / 60) + "min " + sec % 60 + "sec");
-        } else if (sec >= 60) {
-            // only seconds and minutes
-            return (Math.trunc(sec / 60) + "min " + sec % 60 + "sec");
-        } else {
-            // only seconds
-            return (sec + "sec");
-        }
-    }
 }
 
 export default restController(GENERALINFORMATION_SETTINGS_ENDPOINT, GeneralInformation);

interface/src/project/HeatingInformation.tsx

@@ -0,0 +1,70 @@
+import React from "react";
+import {FormButton, restController, RestControllerProps, RestFormLoader, SectionContent} from "../components";
+import {ENDPOINT_ROOT} from "../api";
+import {Box, List, ListItem, ListItemText} from "@material-ui/core";
+import RefreshIcon from "@material-ui/icons/Refresh";
+import {getRealTimeString, stringifyTime} from "./Time";
+import {HeatingInformationState} from "./types";
+
+// define api endpoint
+export const HEATING_ENDPOINT = ENDPOINT_ROOT + "heatinginfo";
+
+type HeatingRestcontollerprops = RestControllerProps<HeatingInformationState>;
+
+class HeatingInformation extends React.Component<HeatingRestcontollerprops> {
+    componentDidMount() {
+        this.props.loadData();
+    }
+
+    render = () => (
+        <SectionContent title='Heizung Information' titleGutter>
+            <RestFormLoader
+                {...this.props}
+                render={props => (
+                    <>
+                        <List>
+                            <ListItem>
+                                <ListItemText
+                                    primary="Heizung lief zuletzt:"
+                                    secondary={props.data.lastheating !== 0 ?
+                                        <>
+                                            vor {stringifyTime(props.data.lastheating)}<br/>
+                                            {getRealTimeString(props.data.lastheating)}
+                                        </> : "noch nie!"}
+                                />
+                            </ListItem>
+                            <ListItem>
+                                <ListItemText
+                                    primary="Letze Heizdauer:"
+                                    secondary={props.data.lastheatduration === 0 ? "-" : props.data.lastheatduration === -1 ? "läuft gerade!" : stringifyTime(props.data.lastheatduration)}
+                                />
+                            </ListItem>
+                            <ListItem>
+                                <ListItemText
+                                    primary="Gesammte Heizdauer / Prozentuelle Einschaltzeit"
+                                    secondary={stringifyTime(props.data.totalheattime) + ' / ' + (props.data.heattimepercent * 100).toFixed(2) + '%'}
+                                />
+                            </ListItem>
+                            <ListItem>
+                                <ListItemText
+                                    primary="Temperatur/Luftfeuchtigkeit:"
+                                    secondary={(props.data.temp !== -1 ? props.data.temp + "C" : "Auslesefehler!") + " / " + (props.data.hum !== -1 ? props.data.hum + "%" : "Auslesefehler!")}
+                                />
+                            </ListItem>
+                        </List>
+                        <Box display="flex" flexWrap="wrap">
+                            <Box flexGrow={1} padding={1}>
+                                <FormButton startIcon={<RefreshIcon/>} variant="contained" color="secondary"
+                                            onClick={this.props.loadData}>
+                                    Refresh
+                                </FormButton>
+                            </Box>
+                        </Box>
+                    </>
+                )}
+            />
+        </SectionContent>
+    );
+}
+
+export default restController(HEATING_ENDPOINT, HeatingInformation);

interface/src/project/PumpControl.tsx

@@ -9,6 +9,7 @@ import { AuthenticatedRoute } from '../authentication';
 
 import GeneralInformation from './GeneralInformation';
 import SettingsController from "./SettingsController";
+import HeatingInformation from "./HeatingInformation";
 
 class PumpControl extends Component<RouteComponentProps> {
 
@@ -21,10 +22,12 @@ class PumpControl extends Component<RouteComponentProps> {
       <MenuAppBar sectionTitle="Wasserpumpensteuerung">
         <Tabs value={this.props.match.url} onChange={this.handleTabChange} variant="fullWidth">
           <Tab value={`/${PROJECT_PATH}/pumpe/information`} label="Information" />
+            <Tab value={`/${PROJECT_PATH}/pumpe/heizung`} label="Heizung" />
           <Tab value={`/${PROJECT_PATH}/pumpe/settings`} label="Einstellungen" />
         </Tabs>
         <Switch>
           <AuthenticatedRoute exact path={`/${PROJECT_PATH}/pumpe/information`} component={GeneralInformation} />
+            <AuthenticatedRoute exact path={`/${PROJECT_PATH}/pumpe/heizung`} component={HeatingInformation} />
           <AuthenticatedRoute exact path={`/${PROJECT_PATH}/pumpe/settings`} component={SettingsController} />
           <Redirect to={`/${PROJECT_PATH}/pumpe/information`} />
         </Switch>

interface/src/project/Time.ts

@@ -0,0 +1,33 @@
+/**
+ * stringify seconds to a pretty format
+ * @param sec number of seconds
+ */
+export function stringifyTime(sec: number): string {
+    if (sec >= 86400) {
+        // display days
+        return (Math.trunc(sec / 86400) + "d " + Math.trunc((sec % 86400) / 3600) + "h " + Math.trunc((sec % 3600) / 60) + "min " + sec % 60 + "sec");
+    } else if (sec >= 3600) {
+        // display hours
+        return (Math.trunc(sec / 3600) + "h " + Math.trunc((sec % 3600) / 60) + "min " + sec % 60 + "sec");
+    } else if (sec >= 60) {
+        // only seconds and minutes
+        return (Math.trunc(sec / 60) + "min " + sec % 60 + "sec");
+    } else {
+        // only seconds
+        return (sec + "sec");
+    }
+}
+
+export function getRealTimeString(runtime: number): string {
+    const timestamp = Date.now();
+
+    const a = new Date(timestamp - (runtime * 1000));
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const year = a.getFullYear();
+    const month = months[a.getMonth()];
+    const date = a.getDate();
+    const hour = a.getHours();
+    const min = "0" + a.getMinutes();
+    const sec = "0" + a.getSeconds();
+    return '[' + date + ' ' + month + ' ' + year + ' ' + hour + ':' + min.substr(-2) + ':' + sec.substr(-2) + ']';
+}

interface/src/project/types.ts

@@ -7,8 +7,6 @@ export interface SettingsState {
 }
 
 export interface GeneralInformaitonState {
-  hum: number;
-  temp: number;
   lastpumptime: number;
   lastWaterOutage: number;
   lastPumpDuration: number;
@@ -16,4 +14,14 @@ export interface GeneralInformaitonState {
   watersensor: boolean;
   pressuresensor: boolean;
   version: string;
+  pumpcycles: number;
+}
+
+export interface HeatingInformationState {
+  lastheating: number;
+  lastheatduration: number;
+  hum: number;
+  temp: number;
+  totalheattime: number;
+  heattimepercent: number;
 }

lib/framework/APSettingsService.cpp

@@ -46,7 +46,7 @@ void APSettingsService::manageAP() {
 void APSettingsService::startAP() {
   Serial.println(F("Starting software access point"));
   WiFi.softAPConfig(_state.localIP, _state.gatewayIP, _state.subnetMask);
-  WiFi.softAP(_state.ssid.c_str(), _state.password.c_str());
+  WiFi.softAP(_state.ssid.c_str(), _state.password.c_str(), 1, !_state.networkVisible);
   if (!_dnsServer) {
     IPAddress apIp = WiFi.softAPIP();
     Serial.print(F("Starting captive portal on "));

lib/framework/APSettingsService.h

@@ -28,6 +28,10 @@
 #define FACTORY_AP_PASSWORD "esp-react"
 #endif
 
+#ifndef FACTORY_AP_VISIBLE
+#define FACTORY_AP_VISIBLE true
+#endif
+
 #ifndef FACTORY_AP_LOCAL_IP
 #define FACTORY_AP_LOCAL_IP "192.168.4.1"
 #endif
@@ -53,10 +57,11 @@ class APSettings {
   IPAddress localIP;
   IPAddress gatewayIP;
   IPAddress subnetMask;
+  bool networkVisible;
 
   bool operator==(const APSettings& settings) const {
     return provisionMode == settings.provisionMode && ssid == settings.ssid && password == settings.password &&
-           localIP == settings.localIP && gatewayIP == settings.gatewayIP && subnetMask == settings.subnetMask;
+           localIP == settings.localIP && gatewayIP == settings.gatewayIP && subnetMask == settings.subnetMask && networkVisible == settings.networkVisible;
   }
 
   static void read(APSettings& settings, JsonObject& root) {
@@ -66,6 +71,7 @@ class APSettings {
     root["local_ip"] = settings.localIP.toString();
     root["gateway_ip"] = settings.gatewayIP.toString();
     root["subnet_mask"] = settings.subnetMask.toString();
+    root["network_visible"] = settings.networkVisible;
   }
 
   static StateUpdateResult update(JsonObject& root, APSettings& settings) {
@@ -81,6 +87,7 @@ class APSettings {
     }
     newSettings.ssid = root["ssid"] | FACTORY_AP_SSID;
     newSettings.password = root["password"] | FACTORY_AP_PASSWORD;
+    newSettings.networkVisible = root["network_visible"] | FACTORY_AP_VISIBLE;
 
     JsonUtils::readIP(root, "local_ip", newSettings.localIP, FACTORY_AP_LOCAL_IP);
     JsonUtils::readIP(root, "gateway_ip", newSettings.gatewayIP, FACTORY_AP_GATEWAY_IP);

platformio.ini

@@ -20,11 +20,12 @@ build_flags=
 lib_compat_mode = strict
 
 ; Uncomment & modify the lines below in order to configure OTA updates
-upload_flags =
-  --port=8266
-  --auth=esp-react
-  --host_port=14515
-upload_port = 192.168.0.230
+;upload_flags =
+;  --port=8266
+;  --auth=esp-react
+;  --host_port=14515
+;upload_port = 192.168.0.230
+;upload_protocol = espota
 
 framework = arduino
 monitor_speed = 115200

src/GeneralInfoService.cpp

@@ -4,13 +4,13 @@
 
 #include "GeneralInfoService.h"
 #include "Pins.h"
+#include "Timer.h"
 
-GeneralInfoService::GeneralInfoService(AsyncWebServer *server, float *lasthum, float *lasttemp) :
-        hum(lasthum),
-        temp(lasttemp),
+GeneralInfoService::GeneralInfoService(AsyncWebServer *server) :
         lastPumpTime(0),
         lastWaterOutage(0),
-        lastPumpDuration(0) {
+        lastPumpDuration(0),
+        pumpCycles(0) {
     server->on(GENERALINFO_SERVICE_PATH, HTTP_GET, std::bind(&GeneralInfoService::reply, this, std::placeholders::_1));
 }
 
@@ -18,31 +18,36 @@ void GeneralInfoService::reply(AsyncWebServerRequest *request) {
     AsyncJsonResponse *response = new AsyncJsonResponse(false, MAX_FEATURES_SIZE);
     JsonObject root = response->getRoot();
 
-    root["temp"] = *temp;
-    root["hum"] = *hum;
+    const uint32_t systime = Timer::getSystemSeconds();
 
-    root["lastpumptime"] = lastPumpTime != 0 ? (millis() - lastPumpTime) / 1000 : 0;
-    root["lastWaterOutage"] = lastWaterOutage != 0 ? (millis() - lastWaterOutage) / 1000 : 0;
-    root["lastPumpDuration"] = lastPumpDuration != 0 ? lastPumpDuration / 1000 : 0;
-    root["runtime"] = millis() / 1000;
+    root["lastpumptime"] = lastPumpTime != 0 ? systime - lastPumpTime : 0;
+    root["lastWaterOutage"] = lastWaterOutage != 0 ? systime - lastWaterOutage : 0;
+    root["lastPumpDuration"] = lastPumpDuration != 0 ? lastPumpDuration : 0;
+    root["runtime"] = systime;
 
     root["watersensor"] = digitalRead(WasserSensorPin) ? true : false;
     root["pressuresensor"] = digitalRead(DruckSensorPin) ? true : false;
 
+    root["pumpcycles"] = pumpCycles;
+
     root["version"] = VERSION;
 
     response->setLength();
     request->send(response);
 }
 
-void GeneralInfoService::setlastPumpTime(unsigned long lastPumpTime) {
+void GeneralInfoService::setlastPumpTime(uint32_t lastPumpTime) {
     this->lastPumpTime = lastPumpTime;
 }
 
-void GeneralInfoService::setlastWaterOutage(unsigned long lastWaterOutage) {
+void GeneralInfoService::setlastWaterOutage(uint32_t lastWaterOutage) {
     this->lastWaterOutage = lastWaterOutage;
 }
 
-void GeneralInfoService::setPumpDuration(unsigned long lastPumpDuration) {
+void GeneralInfoService::setPumpDuration(uint32_t lastPumpDuration) {
     this->lastPumpDuration = lastPumpDuration;
 }
+
+void GeneralInfoService::setPumpCycles(uint32_t cycles) {
+    this->pumpCycles = cycles;
+}

src/GeneralInfoService.h

@@ -17,34 +17,34 @@
 
 class GeneralInfoService {
 public:
-    GeneralInfoService(AsyncWebServer* server, float* lasthum, float* lasttemp);
+    GeneralInfoService(AsyncWebServer* server);
 
     /**
      * sets the last time when the pump was on
      * @param lastPumpTime pump time in ms
      */
-    void setlastPumpTime(unsigned long lastPumpTime);
+    void setlastPumpTime(uint32_t lastPumpTime);
 
     /**
      * sets the last time of a water outage
      * @param lastWaterOutage last wateroutage time in ms
      */
-    void setlastWaterOutage(unsigned long lastWaterOutage);
+    void setlastWaterOutage(uint32_t lastWaterOutage);
 
     /**
      * sets the duration of the last pump cycle
      * @param lastPumpDuration duration in ms
      */
-    void setPumpDuration(unsigned long lastPumpDuration);
+    void setPumpDuration(uint32_t lastPumpDuration);
+
+    void setPumpCycles(uint32_t i);
 
 private:
     void reply(AsyncWebServerRequest* request);
 
-    float * hum;
-    float * temp;
-
     unsigned long lastPumpTime, lastWaterOutage, lastPumpDuration;
 
+    uint32_t pumpCycles;
 };
 
 

src/Heating.cpp

@@ -4,11 +4,118 @@
 
 #include "Heating.h"
 #include "Pins.h"
+#include "Timer.h"
 
+Heating::Heating() : mHeizungTicker(),
+                     mLuefterTicker(),
+                     mTurnOffTicker(),
+                     msettings(nullptr),
+                     mheatingservice(nullptr),
+                     mHeatingStatus(false),
+                     mPumpCycleActive(false),
+                     lasttemp(0),
+                     lasthum(0),
+                     sensor() {}
+
+void Heating::init(unsigned mode, const SettingState *settings, HeatingInfoService *heatingservice) {
+    msettings = settings;
+    mheatingservice = heatingservice;
 
-void Heating::init(unsigned mode, const SettingState* settings) {
     switch (mode) {
         case TIME: {
+            this->handleTimeHeater();
+            break;
+        }
+        case HUMIDITY:
+            mHeatingStatus = false;
+
+            sensor.setPin(TempSensorPin);
+
+            sensor.onData([this](float hum, float temp) {
+                schedule_function([hum, temp, this]() {
+//                    Serial.printf("Temp: %gdegC\n", temp);
+//                    Serial.printf("Humid: %g%%\n", hum);
+
+                    mheatingservice->setSensorData(hum, temp);
+
+                    this->lasttemp = temp;
+                    this->lasthum = hum;
+
+                    this->handleHeatingEvents();
+                });
+            });
+
+            sensor.onError([this](uint8_t e) {
+                this->lasttemp = -1.0;
+                this->lasthum = -1.0;
+
+                mheatingservice->setSensorData(-1.0, -1.0);
+
+                // emergency turnoff of heating
+                if (mHeatingStatus) {
+                    digitalWrite(HeizungPin, LOW);
+                }
+
+//                schedule_function([e]() {
+//                    Serial.printf("Error: %d\n", e);
+//                });
+            });
+
+            mHeizungTicker.attach(10, [this]() {
+                // only check if no pump cycle is active
+                if (!mPumpCycleActive) {
+                    sensor.read();
+                }
+            });
+
+            break;
+        default:
+            break;
+    }
+}
+
+void Heating::handleHeatingEvents() {
+    if (this->lasthum > (float) msettings->heatUp) {
+        // only turn on if turned off
+        if (mHeatingStatus == false) {
+            // turn off active turnoff timers
+            mLuefterTicker.detach();
+            //Serial.println("heating should run now!");
+
+            digitalWrite(LuefterPin, HIGH);
+
+            digitalWrite(HeizungPin, HIGH);
+
+            mHeatingStatus = true;
+            mheatingservice->setLastHeatingStarttime(Timer::getSystemSeconds());
+
+            mheatingservice->setLastHetingEndtime(0);
+        }
+    } else if (this->lasthum < (float) msettings->heatLow) {
+        // if humidity too low turn off heating and fan after 60secs
+        if (mHeatingStatus == true) {
+            digitalWrite(HeizungPin, LOW);
+            ////Serial.println("heating should NOT run now!");
+            // add the heat time it took to the total
+            mheatingservice->addHeatTime(Timer::getSystemSeconds() - mheatingservice->getLastHeatingStartTime());
+
+            // if heating status in on set ticker to turn of fan in 60sec
+            if (mHeatingStatus) {
+                mLuefterTicker.once((float) msettings->fanRuntime, []() {
+                    // turn off fan
+                    digitalWrite(LuefterPin, LOW);
+                    schedule_function([]() {
+                        ////Serial.println("turning off fan");
+                    });
+                });
+            }
+            mheatingservice->setLastHetingEndtime(Timer::getSystemSeconds());
+            mHeatingStatus = false;
+        }
+    }
+}
+
+void Heating::handleTimeHeater() {
     const unsigned percentOn = 20;
     const unsigned refreshperiod = 900;
 
@@ -19,97 +126,46 @@ void Heating::init(unsigned mode, const SettingState* settings) {
         digitalWrite(LuefterPin, HIGH);
         digitalWrite(HeizungPin, HIGH);
 
-                Serial.println("Turning on heating");
+        ////Serial.println("Turning on heating");
 
         mTurnOffTicker.once((int) ((float) refreshperiod * (float) percentOn / 100.0), []() {
             digitalWrite(HeizungPin, LOW);
 
-                    Serial.println("Turned off heating!");
+            ////Serial.println("Turned off heating!");
         });
 
         mLuefterTicker.once((int) (((float) refreshperiod * (float) percentOn / 100.0) + 30.0), []() {
             digitalWrite(LuefterPin, LOW);
 
-                    Serial.println("Turned off fan!");
+            ////Serial.println("Turned off fan!");
         });
     };
 
     func();
     mHeizungTicker.attach(refreshperiod, func);
-            break;
-        }
-        case HUMIDITY:
-            mHeatingStatus = false;
+}
 
-            sensor.setPin(TempSensorPin);
+void Heating::setPumCycleActive(bool active) {
+    mPumpCycleActive = active;
 
-            sensor.onData([this, settings](float hum, float temp) {
-                schedule_function([hum, temp, settings, this]() {
-                    Serial.printf("Temp: %gdegC\n", temp);
-                    Serial.printf("Humid: %g%%\n", hum);
-
-                    this->lasttemp = temp;
-                    this->lasthum = hum;
-
-                    if (hum > (float)settings->heatUp) {
-                        // turn off active turnoff timers
-                        mLuefterTicker.detach();
-                        Serial.println("heating should run now!");
-                        // turn on heating and fan
-                        digitalWrite(LuefterPin, HIGH);
-                        digitalWrite(HeizungPin, HIGH);
-                        mHeatingStatus = true;
-                    } else if (hum < (float)settings->heatLow) {
-                        // if humidity too low turn off heating and fan after 60secs
-                        digitalWrite(HeizungPin, LOW);
-                        Serial.println("heating should NOT run now!");
-
-                        // if heating status in on set ticker to turn of fan in 60sec
-                        if (mHeatingStatus) {
-                            mLuefterTicker.once((float)settings->fanRuntime, []() {
-                                // turn off fan
+    // turn off fan if pumpcycleactive
+    if (active) {
         digitalWrite(LuefterPin, LOW);
-                                schedule_function([]() {
-                                    Serial.println("turning off fan");
-                                });
-                            });
+        digitalWrite(HeizungPin, LOW);
+
+        mHeizungTicker.detach();
+
+        if (mHeatingStatus) {
+            // to add the correct time to the heat min counter!
+            mheatingservice->addHeatTime(Timer::getSystemSeconds() - mheatingservice->getLastHeatingStartTime());
         }
-                        mHeatingStatus = false;
-                    }
-                });
-            });
-
-            sensor.onError([this](uint8_t e) {
-                this->lasttemp = -1.0;
-                this->lasthum = -1.0;
-
-                schedule_function([e]() {
-                    Serial.printf("Error: %d\n", e);
-                });
-            });
-
+    } else {
+        mHeizungTicker.detach();
         mHeizungTicker.attach(10, [this]() {
+            // only check if no pump cycle is active
+            if (!mPumpCycleActive) {
                 sensor.read();
+            }
         });
-
-            break;
-        default:
-            break;
     }
 }
-
-float *Heating::getLastTemp() {
-    return &lasttemp;
-}
-
-float *Heating::getLastHum() {
-    return &lasthum;
-}
-
-Heating::Heating() : mHeizungTicker(),
-                     mLuefterTicker(),
-                     mTurnOffTicker(),
-                     mHeatingStatus(),
-                     lasttemp(0),
-                     lasthum(0),
-                     sensor() {}

src/Heating.h

@@ -8,15 +8,20 @@
 #include <DHT.h>
 #include "Pins.h"
 #include "SettingsService.h"
+#include "HeatingInfoService.h"
 
 class Heating {
 public:
     Heating();
 
-    void init(unsigned mode, const SettingState* settings);
+    /**
+     * initialize the heater
+     * @param mode select the operating mode
+     * @param settings a settings object is needed for HUMIDITY mode to get percent values set by user
+     */
+    void init(unsigned mode, const SettingState* settings, HeatingInfoService *heatingservice);
 
-    float* getLastHum();
-    float* getLastTemp();
+    void setPumCycleActive(bool active);
 
     enum MODES {TIME, HUMIDITY};
 private:
@@ -24,10 +29,26 @@ private:
     Ticker mLuefterTicker;
     Ticker mTurnOffTicker;
 
-    bool mHeatingStatus;
+    const SettingState* msettings;
+    HeatingInfoService *mheatingservice;
+
+    bool mHeatingStatus, mPumpCycleActive;
 
     float lasttemp;
     float lasthum;
 
     DHT22 sensor;
+
+    /**
+     * handle events after successfully received a humidity value
+     * - turn on/off of heating
+     * - afterrun of fan
+     */
+    void handleHeatingEvents();
+
+    /**
+     * handle events for time-heating mode
+     * when to turn on/off heating + fan
+     */
+    void handleTimeHeater();
 };

src/HeatingInfoService.cpp

@@ -0,0 +1,58 @@
+//
+// Created by lukas on 19.12.20.
+//
+
+#include <AsyncJson.h>
+#include "HeatingInfoService.h"
+#include "Timer.h"
+
+HeatingInfoService::HeatingInfoService(AsyncWebServer *server) :
+        hum(-1),
+        temp(-1),
+        lastheating(0),
+        lastheatend(0),
+        totalHeatTime(0) {
+    server->on(HEATINGINFO_SERVICE_PATH, HTTP_GET, std::bind(&HeatingInfoService::reply, this, std::placeholders::_1));
+}
+
+void HeatingInfoService::reply(AsyncWebServerRequest *request) {
+    AsyncJsonResponse *response = new AsyncJsonResponse(false, MAX_FEATURES_SIZE);
+    JsonObject root = response->getRoot();
+
+    root["temp"] = temp;
+    root["hum"] = hum;
+
+    const uint32_t systime = Timer::getSystemSeconds();
+
+    root["lastheating"] = lastheating != 0 ? systime - lastheating : 0;
+    // if lastheating == 0 => there was no cycle upon now
+    // if lastheatend == 0 => heating is currently active
+    root["lastheatduration"] = lastheating == 0 ? 0 : lastheatend == 0 ? -1 : lastheatend - lastheating;
+
+    root["totalheattime"] = this->totalHeatTime;
+    root["heattimepercent"] = (float)this->totalHeatTime / (float)Timer::getSystemSeconds();
+
+    response->setLength();
+    request->send(response);
+}
+
+void HeatingInfoService::setSensorData(float hum, float temp) {
+    this->hum = hum;
+    this->temp = temp;
+}
+
+void HeatingInfoService::setLastHeatingStarttime(unsigned long time) {
+    this->lastheating = time;
+}
+
+void HeatingInfoService::setLastHetingEndtime(unsigned long time) {
+    this->lastheatend = time;
+}
+
+uint32_t HeatingInfoService::getLastHeatingStartTime() {
+    return this->lastheating;
+}
+
+void HeatingInfoService::addHeatTime(uint32_t time) {
+    totalHeatTime += time;
+}

src/HeatingInfoService.h

@@ -0,0 +1,44 @@
+//
+// Created by lukas on 19.12.20.
+//
+
+#ifndef PUMPENSTEUERUNG_HEATINGINFOSERVICE_H
+#define PUMPENSTEUERUNG_HEATINGINFOSERVICE_H
+
+#include <ESPAsyncWebServer.h>
+
+#define MAX_FEATURES_SIZE 256
+#define HEATINGINFO_SERVICE_PATH "/rest/heatinginfo" // set the api backend path
+
+
+class HeatingInfoService {
+public:
+    HeatingInfoService(AsyncWebServer* server);
+
+    void setSensorData(float hum, float temp);
+
+    void setLastHeatingStarttime(unsigned long time);
+    uint32_t getLastHeatingStartTime();
+
+    void setLastHetingEndtime(unsigned long time);
+
+    /**
+     * add time how long the heater heated
+     * @param time time in seconds
+     */
+    void addHeatTime(uint32_t time);
+
+private:
+    void reply(AsyncWebServerRequest* request);
+
+    float hum;
+    float temp;
+
+    unsigned long lastheating;
+    unsigned long lastheatend;
+
+    uint32_t totalHeatTime;
+};
+
+
+#endif //PUMPENSTEUERUNG_HEATINGINFOSERVICE_H

src/Pins.h

@@ -16,6 +16,6 @@
 #define TempSensorPin  D4
 
 // version info
-#define VERSION "v1.2.0"
+#define VERSION "v1.2.4-Alpa1"
 
 #endif //PUMPENSTEUERUNG_PINS_H

src/SettingsService.cpp

@@ -17,12 +17,12 @@ SettingsService::SettingsService(AsyncWebServer *server, SecurityManager *securi
 }
 
 void SettingsService::onConfigUpdated() {
-    Serial.println("switching led!");
+    ////Serial.println("switching led!");
 
     File settingsFile = ESPFS.open("settings.json", "w+");
 
     if (settingsFile) {
-        Serial.println("writing config file!");
+        ////Serial.println("writing config file!");
         StaticJsonDocument<256> doc;
 
         doc["waterOutageWaitDuration"] = _state.waterOutageWaitDuration;
@@ -46,7 +46,7 @@ void SettingsService::begin() {
         // Deserialize the JSON document
         DeserializationError error = deserializeJson(doc, settingsFile);
         if (error) {
-            Serial.println(F("Failed to read file, using default configuration"));
+            ////Serial.println(F("Failed to read file, using default configuration"));
             onConfigUpdated();
             return;
         }
@@ -59,7 +59,7 @@ void SettingsService::begin() {
         _state.heatLow = doc["heatLow"] | 65;
         _state.fanRuntime = doc["fanRuntime"] | 60;
 
-        Serial.println("read config file!");
+        ////Serial.println("read config file!");
 
         settingsFile.close();
     }

src/Timer.cpp

@@ -0,0 +1,10 @@
+//
+// Created by lukas on 09.12.20.
+//
+
+#include <Arduino.h>
+#include "Timer.h"
+
+uint32_t Timer::getSystemSeconds() {
+    return (uint32_t)(micros64() / 1000000);
+}

src/Timer.h

@@ -0,0 +1,18 @@
+//
+// Created by lukas on 09.12.20.
+//
+
+#ifndef PUMPENSTEUERUNG_TIMER_H
+#define PUMPENSTEUERUNG_TIMER_H
+
+class Timer {
+public:
+    /**
+     * get system time in seconds
+     * @return system time in seconds
+     */
+    static uint32_t getSystemSeconds();
+};
+
+
+#endif //PUMPENSTEUERUNG_TIMER_H

src/main.cpp

@@ -5,6 +5,8 @@
 #include "Pins.h"
 #include "GeneralInfoService.h"
 #include "SettingsService.h"
+#include "Timer.h"
+#include "HeatingInfoService.h"
 
 bool allow;
 bool error = false;
@@ -18,67 +20,82 @@ Ticker pumpendauer;
 //WifiManager mang;
 Heating mHeat;
 
-unsigned long turnontime = 0;
+uint32_t turnontime = 0;
+uint32_t pumpcycles = 0;
 
 AsyncWebServer server(80);
 ESP8266React esp8266React(&server);
 
-GeneralInfoService generalinfo = GeneralInfoService(&server, mHeat.getLastHum(), mHeat.getLastTemp());
+GeneralInfoService generalinfo = GeneralInfoService(&server);
+HeatingInfoService heatinginfo = HeatingInfoService(&server);
 SettingsService settingsservice = SettingsService(&server, esp8266React.getSecurityManager());
 
 void pumpeSchalten(bool on) {
     //    digitalWrite(4,on);
     if (on) {
-        Serial.println("versuche Pumpe EIN zuschalten");
+        //Serial.println("versuche Pumpe EIN zuschalten");
         // refresh last pump counter
-        generalinfo.setlastPumpTime(millis());
+        generalinfo.setlastPumpTime(Timer::getSystemSeconds());
     } else {
-        Serial.println("versuche Pumpe AUS zuschalten");
+        //Serial.println("versuche Pumpe AUS zuschalten");
     }
 
     if (allow && !error) {
         if (on) {
-            pumpendauer.once((float)settingsservice.getSettings()->maxpumpduration + 1, []() {
+            pumpcycles++;
+            generalinfo.setPumpCycles(pumpcycles);
+
+            // pump cycle started
+            mHeat.setPumCycleActive(true);
+
+            pumpendauer.once((float) settingsservice.getSettings()->maxpumpduration + 1, []() {
                 //erlaube keine einschaltung von mehr als 60 sek
-                if (millis() - turnontime >= (unsigned)settingsservice.getSettings()->maxpumpduration * 1000 && turnontime != 0) {
+                if (Timer::getSystemSeconds() - turnontime >=
+                    (unsigned) settingsservice.getSettings()->maxpumpduration && turnontime != 0) {
                     //error zu lange
-                    Serial.println("\n\npumpe lief mehr als 10 Minuten durchgaengig");
+                    //Serial.println("\n\npumpe lief mehr als 10 Minuten durchgaengig");
                     pumpeSchalten(false);
                     error = true;
                 }
             });
         } else {
-            generalinfo.setPumpDuration(millis() - turnontime);
+            generalinfo.setPumpDuration(Timer::getSystemSeconds() - turnontime);
+
+            // pump cycle stopped...
+            mHeat.setPumCycleActive(false);
         }
 
         // save pump start time
-        turnontime = millis();
+        turnontime = Timer::getSystemSeconds();
 
         digitalWrite(SchuetzPin, on);
-        Serial.println("[Erfolg] pumpe wird geschalten");
+        //Serial.println("[Erfolg] pumpe wird geschalten");
     } else {
-        Serial.println("[FEHLGESCHLAGEN] Schalten des Schütz gesperrt durch Timeout oder Fehler-- sofortiges ausschalten der pumpe\n");
+        //Serial.println("[FEHLGESCHLAGEN] Schalten des Schütz gesperrt durch Timeout oder Fehler-- sofortiges ausschalten der pumpe\n");
         turnontime = -1;
         digitalWrite(SchuetzPin, LOW);
     }
 }
 
 ICACHE_RAM_ATTR void DruckschalterInt() {
+    schedule_function([]() {
         if (digitalRead(DruckSensorPin) == HIGH) {
             //pumpe einschalten
-        Serial.println("\n\nDruck Sensor EIN");
+            //Serial.println("\n\nDruck Sensor EIN");
             if (digitalRead(WasserSensorPin)) {
-            Serial.println("Wasser Sensor EIN");
+                //Serial.println("Wasser Sensor EIN");
                 pumpeSchalten(true);
             } else {
-            Serial.println("Wasser Sensor aus irgent einem Grund doch nicht ein -- sofort abschalten!");
+                //Serial.println("Wasser Sensor aus irgent einem Grund doch nicht ein -- sofort abschalten!");
                 pumpeSchalten(false);
             }
         } else {
             //pumpe ausschalten
-        Serial.println("\n\nDruck Sensor AUS");
+            //Serial.println("\n\nDruck Sensor AUS");
             pumpeSchalten(false);
         }
+    });
+
 }
 
 // time counter to wait
@@ -86,48 +103,50 @@ int wateroutagewaitduration;
 
 void WasserSensorCheck() {
     if (digitalRead(WasserSensorPin) == LOW) {
-        Serial.println("Wasser Sensor AUS");
+        //Serial.println("Wasser Sensor AUS");
         //kein Wasser dh timer auf 10min stellen
 
         // refresh wateroutage counter
-        generalinfo.setlastWaterOutage(millis());
+        generalinfo.setlastWaterOutage(Timer::getSystemSeconds());
 
         allow = false;
-        Serial.println("Schalte pumpe aus");
+        //Serial.println("Schalte pumpe aus");
         pumpeSchalten(false);
 
-        Serial.println("warte 30min");
+        //Serial.println("warte 30min");
 
         status.detach();
 
         wateroutagewaitduration = settingsservice.getSettings()->waterOutageWaitDuration;
         status.attach(5, []() {
             wateroutagewaitduration -= 5;
-            Serial.print("noch ");
-            Serial.print(wateroutagewaitduration);
-            Serial.println(" Sekunden verbleibend");
+            //Serial.print("noch ");
+            //Serial.print(wateroutagewaitduration);
+            //Serial.println(" Sekunden verbleibend");
 
             if (wateroutagewaitduration <= 0) {
                 if (digitalRead(WasserSensorPin)) {
                     allow = true;
-                    Serial.println("Einschalten der Pumpe wieder erlaubt.");
+                    //Serial.println("Einschalten der Pumpe wieder erlaubt.");
 
                     //pruefen ob drucksensor ein
                     DruckschalterInt();
                 } else {
-                    Serial.print("wassersensor immer noch kein Wasser --> verlaengern um 120min\n\n");
+                    //Serial.print("wassersensor immer noch kein Wasser --> verlaengern um 120min\n\n");
                     WasserSensorCheck();
                 }
                 status.detach();
             }
         });
     } else {
-        Serial.println("Wasser Sensor EIN");
+        //Serial.println("Wasser Sensor EIN");
     }
 }
 
 ICACHE_RAM_ATTR void WasserSensorInt() {
+    schedule_function([]() {
         WasserSensorCheck();
+    });
 }
 
 void setup() {
@@ -148,9 +167,9 @@ void setup() {
 
     // initilize serial connection
     Serial.begin(115200);
-    Serial.println("\n\n\n\nstartup of ESP");
-    Serial.print("Version: ");
-    Serial.println(VERSION);
+    //Serial.println("\n\n\n\nstartup of ESP");
+    //Serial.print("Version: ");
+    //Serial.println(VERSION);
 
 
     //initial measurement of water state
@@ -172,16 +191,16 @@ void setup() {
 
 
     // initialize wifi
-    Serial.println("Initializing wifi");
+    //Serial.println("Initializing wifi");
     esp8266React.begin();
     settingsservice.begin();
     server.begin();
 
     // initialize heating control
-    Serial.println("initializing heating service");
-    mHeat.init(Heating::HUMIDITY, settingsservice.getSettings());
+    //Serial.println("initializing heating service");
+    mHeat.init(Heating::HUMIDITY, settingsservice.getSettings(), &heatinginfo);
 
-    Serial.println("startup sequence complete!\n");
+    //Serial.println("startup sequence complete!\n");
 }