8 files changed, 69 insertions(+), 0 deletions(-)

M module-bsp/board/linux/battery-charger/battery_charger.cpp
M module-bsp/board/rt1051/bsp/battery-charger/battery_charger.cpp
M module-bsp/bsp/battery-charger/battery_charger.hpp
M module-services/service-evtmgr/EventManager.cpp
M module-services/service-evtmgr/WorkerEvent.cpp
M module-services/service-evtmgr/service-evtmgr/BatteryMessages.hpp
M module-sys/SystemManager/SystemManager.cpp
M source/MessageType.hpp

@@ 34,6 34,10 @@ static uint8_t battLevel = 100;
 static bool plugged      = false;
 namespace bsp
 {
+    namespace
+    {
+        std::uint8_t batteryCriticalLevel = 10;
+    } // namespace
 
     static void battery_worker(void *pvp);
 


@@ 111,4 115,15 @@ namespace bsp
             vTaskDelay(50);
         }
     }
+
+    void battery_setCriticalLevel(std::uint8_t level)
+    {
+        batteryCriticalLevel = level;
+    }
+
+    bool battery_isLevelCritical(std::uint8_t level)
+    {
+        return level <= batteryCriticalLevel;
+    }
+
 } // namespace bsp

@@ 100,6 100,10 @@ static xQueueHandle qHandleIrq = NULL;
 
 namespace bsp
 {
+    namespace
+    {
+        std::uint8_t batteryLevelCritical = 10;
+    } // namespace
 
     // STATUS register bits
     enum B_STATUS


@@ 192,6 196,16 @@ namespace bsp
         gpio.reset();
     }
 
+    void battery_setCriticalLevel(std::uint8_t level)
+    {
+        batteryLevelCritical = level;
+    }
+
+    bool battery_isLevelCritical(std::uint8_t level)
+    {
+        return level <= batteryLevelCritical;
+    }
+
     void battery_getBatteryLevel(uint8_t &levelPercent)
     {
         uint16_t val = 0;

@@ 8,6 8,8 @@
 #ifndef MODULE_BSP_BSP_BATTERY_CHARGER_BATTERY_CHARGER_HPP_
 #define MODULE_BSP_BSP_BATTERY_CHARGER_BATTERY_CHARGER_HPP_
 
+#include <cstdint>
+
 namespace bsp{
 
 	enum class batteryChargerRegisters{


@@ 111,6 113,10 @@ namespace bsp{
 	void battery_ClearAllIRQs(void);
 
 	void battery_clearFuelGuageIRQ(void);
+
+	void battery_setCriticalLevel(std::uint8_t level);
+
+	bool battery_isLevelCritical(std::uint8_t level);
 }
 
 BaseType_t BSP_BatteryChargerINOKB_IRQHandler();

@@ 20,6 20,7 @@
 #include <bsp/magnetometer/magnetometer.hpp>
 #include <bsp/rtc/rtc.hpp>
 #include <bsp/torch/torch.hpp>
+#include <bsp/battery-charger/battery_charger.hpp>
 #include <common_data/RawKey.hpp>
 #include <log/log.hpp>
 #include <module-utils/time/time_conversion.hpp>


@@ 285,6 286,12 @@ sys::ReturnCodes EventManager::InitHandler()
         return std::make_shared<sys::ResponseMessage>();
     });
 
+    connect(sevm::BatterySetCriticalLevel(0), [&](sys::Message *msgl) {
+        auto request = static_cast<sevm::BatterySetCriticalLevel *>(msgl);
+        bsp::battery_setCriticalLevel(request->criticalLevel);
+        return std::make_shared<sys::ResponseMessage>();
+    });
+
     // initialize keyboard worker
     EventWorker = std::make_unique<WorkerEvent>(this);
 

@@ 28,6 28,7 @@
 #include <service-audio/AudioMessage.hpp>
 #include <service-desktop/Constants.hpp>
 #include <service-desktop/DesktopMessages.hpp>
+#include <SystemManager/SystemManager.hpp>
 
 extern "C"
 {


@@ 97,6 98,10 @@ bool WorkerEvent::handleMessage(uint32_t queueID)
             message->levelPercents = battLevel;
             message->fullyCharged  = false;
             sys::Bus::SendUnicast(message, service::name::evt_manager, this->service);
+            if (bsp::battery_isLevelCritical(battLevel)) {
+                auto levelCriticalMessage = std::make_shared<sevm::BatteryLevelCriticalMessage>();
+                sys::Bus::SendUnicast(levelCriticalMessage, service::name::system_manager, this->service);
+            }
         }
         if (notification & static_cast<uint8_t>(bsp::batteryIRQSource::INOKB)) {
             bool status;

@@ 29,4 29,19 @@ namespace sevm
         }
         bool plugged = false;
     };
+    class BatterySetCriticalLevel : public Message
+    {
+      public:
+        BatterySetCriticalLevel(std::uint8_t level)
+            : Message(MessageType::EVMBatterySetCriticalLevel), criticalLevel(level)
+        {}
+        std::uint8_t criticalLevel = 0;
+    };
+
+    class BatteryLevelCriticalMessage : public Message
+    {
+      public:
+        BatteryLevelCriticalMessage() : Message(MessageType::EVMBatteryLevelCritical)
+        {}
+    };
 } // namespace sevm

@@ 312,6 312,11 @@ namespace sys
             return MessageNone{};
         });
 
+        connect(sevm::BatteryLevelCriticalMessage(), [&](Message *) {
+            LOG_INFO("Battery Critical Level");
+            return MessageNone{};
+        });
+
         return ReturnCodes::Success;
     }
 

@@ 166,6 166,8 @@ enum class MessageType
     // battery charger messages
     EVMBatteryLevel,
     EVMChargerPlugged,
+    EVMBatterySetCriticalLevel,
+    EVMBatteryLevelCritical,
     // rtc messages
     EVMMinuteUpdated, ///< This message is send to current focused application on every minute time change.
     EVMTimeUpdated,   ///< This message is send on every time update.