Merge pull request #52 from AIFanatic/feature/battery

Feature/battery

firmware/.gitignore

@@ -44,6 +44,7 @@ Temporary Items
 .apdisk
 
 ### PlatformIO ###
+.pio
 .pioenvs
 .piolibdeps
 .clang_complete

firmware/data/web/js/setup.js

@@ -22,9 +22,6 @@ $(document).ready(function() {
 
                         var settingValue = settings[key];
                         var newBox = $('<div class="box"></div>');
-                        if (settingValue != "true" && settingValue != "false") {
-                            settingValue = settingValue + "s";
-                        }
 
                         newBox.text(settingParsed + ": " + settingValue);
 

firmware/platformio.ini

@@ -18,4 +18,4 @@ lib_deps =
     ArduinoJson-esphomelib
     ESP Async WebServer
     GxEPD
-    Pushbutton
+    Pushbutton

firmware/src/app/Manager.cpp

@@ -2,7 +2,6 @@
 #include "./views/MainView.h"
 #include "./views/TickerView.h"
 #include "./views/SetupView.h"
-#include "./views/DisconnectedView.h"
 #include "./views/LoadingView.h"
 #include "./views/UpdateView.h"
 
@@ -14,26 +13,38 @@ Manager::Manager() {
     tickers = new Tickers(this);
     alarms = new Alarms(this);
     updater = new Updater(this);
+    battery = new Battery(this);
+    deepSleep = new DeepSleep(this);
 
     speaker = new SPEAKER();
     speaker->begin(SPEAKER_PIN_PIN, 0);
 
-    render->clearScreen();
+    // Setup pins
+    pinMode(RED_LED_PIN, OUTPUT);
+    pinMode(VBAT_PIN, INPUT);
+    pinMode(CHARGE_PIN, INPUT);
 
-    webserver->needNetworkReconnect = true;
+    wakeup();
 };
 
 Manager::~Manager() {
 };
 
+void Manager::wakeup() {
+    // If device is not awaken by deep sleep load main view
+    if(!deepSleep->hasBootedFromDeepSleep()) {
+        webserver->needNetworkReconnect = true;
+        render->clearScreen(false);
+        setCurrentViewIndex(MAIN_VIEW);
+    }
+
+    show(getCurrentViewIndex());
+}
+
 // TODO: Ugly, fix
 void Manager::show(int index) {
     isInitializingLayout = true;
 
-    // if(currentView) {
-    //     currentView = nullptr;
-    // }
-
     if(index == MAIN_VIEW) {
         currentView = new MainView(this);
     }
@@ -43,55 +54,44 @@ void Manager::show(int index) {
     else if(index == SETUP_VIEW) {
         currentView = new SetupView(this);
     }
-    else if(index == DISCONNECTED_VIEW) {
-        currentView = new DisconnectedView(this);
-    }
     else if(index == LOADING_VIEW) {
         currentView = new LoadingView(this);
     }
     else if(index == UPDATE_VIEW) {
         currentView = new UpdateView(this);
     }
 
-    currentIndex = index;
+    setCurrentViewIndex(index);
 
     isInitializingLayout = false;
 };
 
 // TODO: Ugly, fix
 void Manager::update() {
+    int currentViewIndex = getCurrentViewIndex();
+
     if(!isInitializingLayout) {
-        if(currentIndex == MAIN_VIEW) {
-            (reinterpret_cast<MainView *>(currentView))->update();
+        if(currentViewIndex == MAIN_VIEW) {
+            (static_cast<MainView *>(currentView))->update();
         }
-        else if(currentIndex == TICKER_VIEW) {
-            (reinterpret_cast<TickerView *>(currentView))->update();
+        else if(currentViewIndex == TICKER_VIEW) {
+            (static_cast<TickerView *>(currentView))->update();
         }
-        else if(currentIndex == SETUP_VIEW) {
-            (reinterpret_cast<SetupView *>(currentView))->update();
+        else if(currentViewIndex == SETUP_VIEW) {
+            (static_cast<SetupView *>(currentView))->update();
         }
-        else if(currentIndex == DISCONNECTED_VIEW) {
-            (reinterpret_cast<DisconnectedView *>(currentView))->update();
+        else if(currentViewIndex == LOADING_VIEW) {
+            (static_cast<LoadingView *>(currentView))->update();
         }
-        else if(currentIndex == LOADING_VIEW) {
-            (reinterpret_cast<LoadingView *>(currentView))->update();
-        }
-        else if(currentIndex == UPDATE_VIEW) {
-            (reinterpret_cast<UpdateView *>(currentView))->update();
+        else if(currentViewIndex == UPDATE_VIEW) {
+            (static_cast<UpdateView *>(currentView))->update();
         }
     }
 
     webserver->update();
-
-    if(!webserver->hasInternetAccess && currentIndex != DISCONNECTED_VIEW && currentIndex != SETUP_VIEW) {
-        show(DISCONNECTED_VIEW);
-    }
-
     speaker->update();
-}
-
-int Manager::getCurrentIndex() {
-    return currentIndex;
+    battery->update();
+    deepSleep->update();
 }
 
 void *Manager::getCurrentView() {

firmware/src/app/Manager.h

@@ -9,17 +9,20 @@
 #include "./controller/Alarms.h"
 #include "./controller/Speaker.h"
 #include "./controller/Updater.h"
+#include "./controller/Battery.h"
+#include "./controller/DeepSleep.h"
 
 #include "../variables.h"
 
+#include "./helpers/RTC.h"
+
 class Manager {
     public:
         Manager();
         ~Manager(void);
 
         void update();
         void show(int index);
-        int getCurrentIndex();
         void *getCurrentView();
 
         Render *render;
@@ -29,12 +32,16 @@ class Manager {
         Settings *settings;
         Tickers *tickers;
         Alarms *alarms;
-        Updater *updater;
-
         SPEAKER *speaker;
+        Updater *updater;
+        Battery *battery;
+        DeepSleep *deepSleep;
 
     private:
-        int currentIndex;
+        void wakeup();
+
+        void setCurrentViewIndex(int value) { RTC::write(RTC_STORAGE::CURRENT_VIEW_INDEX, value); }
+        int getCurrentViewIndex() { return RTC::read(RTC_STORAGE::CURRENT_VIEW_INDEX); }
 
         void *currentView;
 

firmware/src/app/controller/Alarms.cpp

@@ -90,10 +90,7 @@ void Alarms::checkAlarms() {
             if(tickerPrice > 0) {
                 if((type == TYPE_ABOVE && tickerPrice >= price) ||
                    (type == TYPE_BELOW && tickerPrice <= price)) {
-                    // manager->speaker->tone(2240);
-                    // delay(duration * 1000);
-                    // manager->speaker->mute();
-                    manager->speaker->beep(frequency, (duration * 1000) / beeps, beeps);
+                    manager->speaker->beep(frequency, duration / beeps, beeps);
                     manager->speaker->mute();
 
                     alarms.remove(j);

firmware/src/app/controller/Battery.cpp

@@ -0,0 +1,62 @@
+#include "Battery.h"
+
+#include "../Manager.h"
+
+Battery::Battery(Manager *_manager) {
+    manager = _manager;
+
+    isCharging = getIsCharging();
+    chargePercentage = getChargePercentage();
+}
+
+void Battery::requestBatteryStatus(AsyncWebServerRequest *request) {
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& response = jsonBuffer.createObject();
+
+    DynamicJsonBuffer batteryStatusBuffer;
+    JsonObject& batteryStatus = batteryStatusBuffer.createObject();
+    batteryStatus["charging"] = isCharging;
+    batteryStatus["percentage"] = chargePercentage;
+
+    DynamicJsonBuffer buffer;
+    response["status"] = "ok";
+    response["message"] = batteryStatus;
+
+    String str;
+    response.printTo(str);
+    request->send(200, "application/json", str);
+}
+
+bool Battery::getIsCharging() {
+    int charge = analogRead(CHARGE_PIN);
+
+    return charge > 100 ? false : true;
+}
+
+int Battery::getChargePercentage() {
+    int vbat = analogRead(VBAT_PIN);
+
+    if(isCharging) {
+        vbat -= BATTERY_CHARGE_DIFFERENCE_ADC;
+    }
+
+    return constrain(map(vbat, BATTERY_ZERO_CHARGE_ADC, BATTERY_FULL_CHARGE_ADC, 0, 100), 0, 100);
+}
+
+void Battery::update() {
+    long currentTime = Utils::getCurrentTime();
+
+    if((currentTime - lastUpdate) > BATTERY_CHECK_FREQUENCY) {
+        isCharging = getIsCharging();
+        chargePercentage = getChargePercentage();
+
+        if(isCharging && chargePercentage <= BATTERY_CHARGED_PERCENTAGE) {
+            digitalWrite(RED_LED_PIN, HIGH);
+        }
+        else {
+            digitalWrite(RED_LED_PIN, LOW);
+        }
+
+        lastUpdate = currentTime;
+    }
+}

firmware/src/app/controller/Battery.h

@@ -0,0 +1,31 @@
+#ifndef Battery_H_
+#define Battery_H_
+
+#include "Arduino.h"
+#include <ESPAsyncWebServer.h>
+#include <ArduinoJson.h>
+
+class Manager;
+
+class Battery {
+public:
+    Battery(Manager *_manager);
+    ~Battery(void);
+
+    void update();
+
+    void requestBatteryStatus(AsyncWebServerRequest *request);
+
+    bool isCharging;
+    int chargePercentage;
+
+private:
+    bool getIsCharging();
+    int getChargePercentage();
+
+    Manager *manager;
+
+    long lastUpdate = 0;
+};
+
+#endif

firmware/src/app/controller/DeepSleep.cpp

@@ -0,0 +1,55 @@
+#include "DeepSleep.h"
+
+#include "../Manager.h"
+
+DeepSleep::DeepSleep(Manager *_manager) {
+    manager = _manager;
+};
+
+int DeepSleep::getWakeupCause() {
+    return esp_sleep_get_wakeup_cause();
+}
+
+bool DeepSleep::hasBootedFromDeepSleep() {
+    return (esp_sleep_get_wakeup_cause() != ESP_SLEEP_WAKEUP_UNDEFINED);
+}
+
+bool DeepSleep::isGoingToDeepSleep() {
+    return needDeepSleep;
+}
+
+bool DeepSleep::canEnterDeepSleep() {
+    if(Utils::getBootCurrentTime() <= minAwakeBootTime) {
+        return false;
+    }
+
+    // if(manager->battery->isCharging) {
+    //     return false;
+    // }
+
+    return true;
+}
+void DeepSleep::enterDeepSleep() {
+    if(!canEnterDeepSleep()) {
+        return;
+    }
+
+    needDeepSleep = true;
+}
+
+void DeepSleep::setMinAwakeBootTimeOffset(long offsetMillis) {
+    minAwakeBootTime = Utils::getBootCurrentTime() + offsetMillis;
+}
+
+void DeepSleep::update() {
+    if(needDeepSleep) {
+        if(sleepCountdown > 0) {
+            sleepCountdown--;
+            return;
+        }
+        esp_sleep_enable_ext0_wakeup(LEFT_BUTTON, LOW);
+        esp_sleep_enable_ext0_wakeup(OK_BUTTON, LOW);
+        esp_sleep_enable_ext0_wakeup(RIGHT_BUTTON, LOW);
+        esp_deep_sleep_start();
+    }
+}

firmware/src/app/controller/DeepSleep.h

@@ -0,0 +1,35 @@
+#ifndef DeepSleep_h
+#define DeepSleep_h
+
+#include <Arduino.h>
+
+class Manager;
+
+class DeepSleep {
+    public:
+        DeepSleep(Manager *_manager);
+        ~DeepSleep(void);
+
+        int getWakeupCause();
+
+        bool hasBootedFromDeepSleep();
+
+        bool canEnterDeepSleep();
+        void enterDeepSleep();
+        bool isGoingToDeepSleep();
+
+        void setMinAwakeBootTimeOffset(long offsetMillis);
+
+        void update();
+
+    private:
+        Manager *manager;
+
+        long minAwakeBootTime;
+
+        bool needDeepSleep = false;
+
+        int sleepCountdown = 1000;
+};
+
+#endif