From 9179b672f5fc58d2ddee8b9ee9a005d286926af9 Mon Sep 17 00:00:00 2001
From: Thomas Basler <thomas@familie-basler.net>
Date: Sat, 5 Aug 2023 01:25:53 +0200
Subject: [PATCH] Use lock_guard to simplify code

---
 include/Datastore.h |   6 +--
 src/Datastore.cpp   | 111 +++++++++++++-------------------------------
 2 files changed, 35 insertions(+), 82 deletions(-)

diff --git a/include/Datastore.h b/include/Datastore.h
index 8492319..fd42174 100644
--- a/include/Datastore.h
+++ b/include/Datastore.h
@@ -2,12 +2,10 @@
 #pragma once
 
 #include <TimeoutHelper.h>
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
+#include <mutex>
 
 class DatastoreClass {
 public:
-    DatastoreClass();
     void init();
     void loop();
 
@@ -61,7 +59,7 @@ public:
 
 private:
     TimeoutHelper _updateTimeout;
-    SemaphoreHandle_t _xSemaphore;
+    std::mutex _mutex;
 
     float _totalAcYieldTotalEnabled = 0;
     float _totalAcYieldDayEnabled = 0;
diff --git a/src/Datastore.cpp b/src/Datastore.cpp
index 875a877..0afe2c7 100644
--- a/src/Datastore.cpp
+++ b/src/Datastore.cpp
@@ -6,19 +6,8 @@
 #include "Configuration.h"
 #include <Hoymiles.h>
 
-#define DAT_SEMAPHORE_TAKE() \
-    do {                     \
-    } while (xSemaphoreTake(_xSemaphore, portMAX_DELAY) != pdPASS)
-#define DAT_SEMAPHORE_GIVE() xSemaphoreGive(_xSemaphore)
-
 DatastoreClass Datastore;
 
-DatastoreClass::DatastoreClass()
-{
-    _xSemaphore = xSemaphoreCreateMutex();
-    DAT_SEMAPHORE_GIVE(); // release before first use
-}
-
 void DatastoreClass::init()
 {
     _updateTimeout.set(1000);
@@ -32,7 +21,7 @@ void DatastoreClass::loop()
         uint8_t isReachable = 0;
         uint8_t pollEnabledCount = 0;
 
-        DAT_SEMAPHORE_TAKE();
+        std::lock_guard<std::mutex> lock(_mutex);
 
         _totalAcYieldTotalEnabled = 0;
         _totalAcYieldTotalDigits = 0;
@@ -116,136 +105,102 @@ void DatastoreClass::loop()
 
         _totalDcIrradiation = _totalDcIrradiationInstalled > 0 ? _totalDcPowerIrradiation / _totalDcIrradiationInstalled * 100.0f : 0;
 
-        DAT_SEMAPHORE_GIVE();
-
         _updateTimeout.reset();
     }
 }
 
 float DatastoreClass::getTotalAcYieldTotalEnabled()
 {
-    DAT_SEMAPHORE_TAKE();
-    float retval = _totalAcYieldTotalEnabled;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalAcYieldTotalEnabled;
 }
 
 float DatastoreClass::getTotalAcYieldDayEnabled()
 {
-    DAT_SEMAPHORE_TAKE();
-    float retval = _totalAcYieldDayEnabled;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalAcYieldDayEnabled;
 }
 
 float DatastoreClass::getTotalAcPowerEnabled()
 {
-    DAT_SEMAPHORE_TAKE();
-    float retval = _totalAcPowerEnabled;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalAcPowerEnabled;
 }
 
 float DatastoreClass::getTotalDcPowerEnabled()
 {
-    DAT_SEMAPHORE_TAKE();
-    float retval = _totalDcPowerEnabled;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalDcPowerEnabled;
 }
 
 float DatastoreClass::getTotalDcPowerIrradiation()
 {
-    DAT_SEMAPHORE_TAKE();
-    float retval = _totalDcPowerIrradiation;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalDcPowerIrradiation;
 }
 
 float DatastoreClass::getTotalDcIrradiationInstalled()
 {
-    DAT_SEMAPHORE_TAKE();
-    float retval = _totalDcIrradiationInstalled;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalDcIrradiationInstalled;
 }
 
 float DatastoreClass::getTotalDcIrradiation()
 {
-    DAT_SEMAPHORE_TAKE();
-    float retval = _totalDcIrradiation;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalDcIrradiation;
 }
 
 unsigned int DatastoreClass::getTotalAcYieldTotalDigits()
 {
-    DAT_SEMAPHORE_TAKE();
-    unsigned int retval = _totalAcYieldTotalDigits;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalAcYieldTotalDigits;
 }
 
 unsigned int DatastoreClass::getTotalAcYieldDayDigits()
 {
-    DAT_SEMAPHORE_TAKE();
-    unsigned int retval = _totalAcYieldDayDigits;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalAcYieldDayDigits;
 }
 
 unsigned int DatastoreClass::getTotalAcPowerDigits()
 {
-    DAT_SEMAPHORE_TAKE();
-    unsigned int retval = _totalAcPowerDigits;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalAcPowerDigits;
 }
 
 unsigned int DatastoreClass::getTotalDcPowerDigits()
 {
-    DAT_SEMAPHORE_TAKE();
-    unsigned int retval = _totalDcPowerDigits;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _totalDcPowerDigits;
 }
 
 bool DatastoreClass::getIsAtLeastOneReachable()
 {
-    DAT_SEMAPHORE_TAKE();
-    bool retval = _isAtLeastOneReachable;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _isAtLeastOneReachable;
 }
 
 bool DatastoreClass::getIsAtLeastOneProducing()
 {
-    DAT_SEMAPHORE_TAKE();
-    bool retval = _isAtLeastOneProducing;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _isAtLeastOneProducing;
 }
 
 bool DatastoreClass::getIsAllEnabledProducing()
 {
-    DAT_SEMAPHORE_TAKE();
-    bool retval = _isAllEnabledProducing;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _isAllEnabledProducing;
 }
 
 bool DatastoreClass::getIsAllEnabledReachable()
 {
-    DAT_SEMAPHORE_TAKE();
-    bool retval = _isAllEnabledReachable;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _isAllEnabledReachable;
 }
 
 bool DatastoreClass::getIsAtLeastOnePollEnabled()
 {
-    DAT_SEMAPHORE_TAKE();
-    bool retval = _isAtLeastOnePollEnabled;
-    DAT_SEMAPHORE_GIVE();
-    return retval;
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _isAtLeastOnePollEnabled;
 }