Merge pull request #3 from Girgitt/1-re-enable-screen-saver

1 re enable screen saver

main/AppContext.cpp

@@ -93,6 +93,7 @@ namespace ctx
       }
       if (mModel.mTimeZone != "")
       {
+        delay(100);  // trying to avoid ntp occasionally corrupting heap on startup
         mNTPSync = std::make_shared<ntp::NTPSync>(mModel.mTimeZone);
         mNTPSync->syncTime();
       }

main/AppScreen.ipp

@@ -8,6 +8,8 @@
 #include <touch/TouchDriver.h>
 #include <util/varianthelper.hpp>
 
+#include <SharedGlobalState.h>
+
 #include "Arduino.h"
 #include "SPI.h"
 
@@ -22,6 +24,8 @@ extern "C"
 
 namespace gfx
 {
+  //std::shared_ptr<sgs::SharedGlobalState> global_state = sgs::SharedGlobalState::getInstance();
+
   static const int kStatusBarHeight = 20;
 
   template<class ScreenDriver, class NavigationDriver>
@@ -162,7 +166,11 @@ namespace gfx
     std::lock_guard<std::mutex> guard(viewMutex);
     auto tapEvent = mNavigation.tapEvent();
     // FIXME: screen saver is broken - activates on touch and not on timeout (automatically) and does not deactivate 
-    // mScreenSaver();
+    if(mScreenSaver()){
+      // screen saver returned IGNORE_TOUCH_ON_WAKEUP
+      return;
+    }
+
 
     // // Abort when Screensaver is on and no touch event happened.
     // if (!mScreenSaver.tapped(tapEvent))

main/CMakeLists.txt

@@ -87,6 +87,7 @@ set(PLATFORM_SRC
 set(COMPONENT_SRCS 
     "AppContext.cpp"
     "main.cpp"
+    "SharedGlobalState.cpp"
     ${FS_SRC}
     ${UI_SRC}
     ${MQTT_SRC}

main/SharedGlobalState.cpp

@@ -0,0 +1,32 @@
+#include "SharedGlobalState.h"
+#include <memory> 
+
+namespace sgs {
+// when using with C-compatible functions version
+SharedGlobalState& sharedGlobalState = SharedGlobalState::getInstance();
+
+// std::shared_ptr<SharedGlobalState> SharedGlobalState::getInstance() {
+//     static std::shared_ptr<SharedGlobalState> instance = std::make_shared<SharedGlobalState>();
+//     return instance;
+// }
+
+}
+
+// Implementation of C-compatible functions
+
+extern "C" {
+
+void* sharedGlobalStateGetInstance() {
+    return reinterpret_cast<void*>(&sgs::SharedGlobalState::getInstance());
+}
+
+int sharedGlobalStateGetUptime(void* instance) {
+    return static_cast<sgs::SharedGlobalState*>(instance)->getUptime();
+}
+
+void sharedGlobalStateTickUptimeMs(void* instance, int ms) {
+    static_cast<sgs::SharedGlobalState*>(instance)->tickUptimeMs(ms);
+}
+
+
+} // extern "C"

main/SharedGlobalState.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <cmath>
+
+extern "C" 
+{
+  #include "esp_log.h"
+}
+
+namespace sgs 
+{
+    static const char *LOG_TAG = "SharedGlobalState";
+
+    class SharedGlobalState {
+    public:
+        SharedGlobalState() : uptime_sec(0), last_log_print_sec(0), uptime_ms(0), last_tap_ms(0), sec_since_last_tap(0) {}
+
+        // when using with C-compatible functions version
+        static SharedGlobalState& getInstance() {
+            static SharedGlobalState instance;
+            return instance;
+        }
+        //static std::shared_ptr<SharedGlobalState> getInstance();
+
+        void tickUptimeMs(int ms){
+            std::lock_guard<std::mutex> lock(mutex);
+            uptime_ms += static_cast<long>(ms);
+            uptime_sec = std::floor(static_cast<double>(uptime_ms)/1000.0);
+
+            // in case of uptime_ms overflow every 49.7 days the idle time is truncated to max 24h
+            if (last_tap_ms > uptime_ms)
+            {
+                ESP_LOGI(LOG_TAG, "uptime_ms overflow"); 
+                last_tap_ms = 0;
+                if (sec_since_last_tap < 24 * 3600)
+                {
+                    uptime_ms = sec_since_last_tap * 1000;
+                }
+                else{
+                    uptime_ms = 24 * 3600 * 1000;
+                }
+            }
+            sec_since_last_tap = static_cast<int>(std::floor((uptime_ms - last_tap_ms) / 1000.0));
+
+            if (uptime_sec % 5 == 0){
+                if(uptime_sec != last_log_print_sec){
+                    ESP_LOGI(LOG_TAG, "uptime %d sec", uptime_sec);        
+                    ESP_LOGI(LOG_TAG, "sec_since_last_tap  %d sec", sec_since_last_tap);
+                    last_log_print_sec = uptime_sec;
+                }
+            }
+
+        }
+        void setUptime(int new_uptime) {
+            std::lock_guard<std::mutex> lock(mutex);
+            uptime_sec = new_uptime;
+        }
+
+        int getUptime() const {
+            std::lock_guard<std::mutex> lock(mutex);
+            return uptime_sec;
+        }
+
+        int getIdleTimeSec() const {
+            std::lock_guard<std::mutex> lock(mutex);
+            return sec_since_last_tap;
+        }
+
+        void registerTap(){
+            std::lock_guard<std::mutex> lock(mutex);
+
+            ESP_LOGI("SharedGlobalState", "registering tap");
+
+            last_tap_ms = uptime_ms;
+        }
+
+    private:
+        int uptime_sec;
+        int last_log_print_sec;
+        long uptime_ms;
+        long last_tap_ms;
+        int sec_since_last_tap;
+        mutable std::mutex mutex;   // Note: mutable is used to allow locking in const member functions
+    };
+
+    // Define the shared instance
+    extern SharedGlobalState& sharedGlobalState;
+
+} // namespace sgs

main/config/PlatformInject.hpp

@@ -42,6 +42,9 @@
   auto ScreenOnOffSwitch = [](ScreenDriver* driver, bool on, bool inverted = false)
   {
     driver->setSleep(!on);
+    auto axp = AXP192();
+    axp.SetDCDC3(!on);   // turn screen off / on
+    axp.SetLed(!on);
   };
   auto InitializeScreen = [](ScreenDriver* driver)
   {

main/fs/ConfigReader.cpp

@@ -6,6 +6,9 @@ extern "C"
   #include "esp_log.h"
 }
 
+
+#define LOG_TAG "config reader"
+
 namespace fs
 {
 
@@ -302,9 +305,24 @@ namespace fs
 
       read(document, "screenSaverMinutes", [&](int mins)
           {
+            ESP_LOGI(LOG_TAG,  "overriden mScreensaverMins to  %d min", mins);
             hwConfig.mScreensaverMins = mins;
           }
         );
+
+      read(document, "screenSaverPowerSaveEnabled", [&](bool screenSaverPowerSaveEnabled)
+          {
+            ESP_LOGI(LOG_TAG,  "overriden screenSaverPowerSaveEnabled to  %d", screenSaverPowerSaveEnabled);
+            hwConfig.mIsScreenSaverPowerSaveEnabled = screenSaverPowerSaveEnabled;
+          }
+        );
+
+      read(document, "powerSaveMHz", [&](int powerSaveMHz)
+          {
+            ESP_LOGI(LOG_TAG,  "overriden powerSaveMHz to  %d MHz", powerSaveMHz);
+            hwConfig.mPowerSaveFreq = powerSaveMHz;
+          }
+        );
 
       read(document, "screenRotationAngle", [&](int angle)
           {

main/main.cpp

@@ -5,28 +5,36 @@
 #include <config/Config.h>
 #include <fs/ConfigReader.hpp>
 #include "AppScreen.hpp"
+#include "SharedGlobalState.h"
 
 #include <memory>
+#include "esp_log.h"
 
 extern "C"
 {
   #include "freertos/FreeRTOS.h"
   #include "freertos/task.h"
   #include "esp_task_wdt.h"
   #include "nvs_flash.h"
+
 }
 
 #define MAINLOOPCORE 0
 TaskHandle_t runLoopHandle = NULL;
-bool loopTaskWDTEnabled = false; // Enable if watchdog running
+bool loopTaskWDTEnabled = true; // Enable if watchdog running
 
 std::shared_ptr<ctx::AppContext> mpAppContext(new ctx::AppContext());
 gfx::AppScreen<ScreenDriver, NavigationDriver> mScreen(mpAppContext);
+//std::shared_ptr<sgs::SharedGlobalState> global_state = sgs::SharedGlobalState::getInstance();
 
 extern "C" 
 {
   void runLoop(void *pvParameters);
   void setupApp();
+
+  void* sharedGlobalStateGetInstance();
+  void  sharedGlobalStateTickUptimeMs(void* instance, int ms);
+  void* sgs_instance = sharedGlobalStateGetInstance();
 
   void app_main()
   {
@@ -69,14 +77,21 @@ extern "C"
 
   void runLoop(void *pvParameters)
   {
+    //esp_log_level_set("*", ESP_LOG_INFO);
+    int loop_delay_ms = 50;
+    ESP_LOGI("main", "starting main loop");
+
     for(;;)
     {
         if (loopTaskWDTEnabled)
         {
           esp_task_wdt_reset();
         }
+
         mScreen.draw();
-        delay(50);
+        sharedGlobalStateTickUptimeMs(sgs_instance, loop_delay_ms);
+        //global_state->tickUptimeMs(loop_delay_ms);
+        delay(loop_delay_ms);
     }
   }
 }

main/model/HardwareConfig.hpp

@@ -13,5 +13,8 @@ namespace config
     bool mIsTouchXAxisInverted = kTOUCH_X_AXIS_INVERTED;
     bool mIsTouchYAxisInverted = kTOUCH_Y_AXIS_INVERTED;
     bool mIsDisplayColorInverted = kDISPLAY_INVERTED;
+    bool mIsScreenSaverPowerSaveEnabled = true;
+    int mPowerSaveFreq = 80;
+    int mPerformanceFreq = 240;
   };
 }