8 files changed, 207 insertions(+), 7 deletions(-)

M module-bsp/board/rt1051/bellpx/CMakeLists.txt
M module-bsp/board/rt1051/bellpx/board/BoardDefinitions.hpp
M module-bsp/board/rt1051/bellpx/board/pin_mux.h
A module-bsp/board/rt1051/bellpx/bsp/battery-charger/battery-charger.cpp
A module-bsp/board/rt1051/bellpx/bsp/battery-charger/battery-charger.hpp
M module-bsp/board/rt1051/bellpx/hal/battery_charger/BatteryCharger.cpp
M module-bsp/board/rt1051/bellpx/irq_gpio.cpp
M module-bsp/board/rt1051/bellpx/pin_mux.c

@@ 17,6 17,7 @@ target_sources(
         bsp/switches/switches.cpp
         bsp/rotary_encoder/rotary_encoder.cpp
         bsp/bell_temp_sensor/bell_temp_sensor.cpp
+        bsp/battery-charger/battery-charger.cpp
         pin_mux.c
         clock_config.cpp
         irq_gpio.cpp

@@ 153,4 153,10 @@ enum class BoardDefinitions
 
     BELL_WAKEUP_GPIO = static_cast<int>(drivers::GPIOInstances ::GPIO_5),
     BELL_WAKEUP      = 0, // SNVS_WAKEUP_GPIO5_IO00
+
+    BELL_BATTERY_CHARGER_GPIO       = static_cast<int>(drivers::GPIOInstances ::GPIO_2),
+    BELL_BATTERY_CHARGER_CHGEN_PIN  = 23,
+    BELL_BATTERY_CHARGER_ACOK_PIN   = 22,
+    BELL_BATTERY_CHARGER_CHGOK_GPIO = static_cast<int>(drivers::GPIOInstances ::GPIO_1),
+    BELL_BATTERY_CHARGER_CHGOK_PIN  = 0,
 };

@@ 124,9 124,9 @@ extern "C"
 /**
  * BATTERY CHARGER PINMUX DEFINITIONS
  */
-#define PINUMX_BATTERY_CHARGER_CHGINT IOMUXC_GPIO_AD_B0_00_GPIO1_IO00
-#define PINUMX_BATTERY_CHARGER_ACOK   IOMUXC_GPIO_AD_B0_02_GPIO1_IO02
-#define PINUMX_BATTERY_CHARGER_CHGEN  IOMUXC_GPIO_AD_B0_15_GPIO1_IO15
+#define PINUMX_BATTERY_CHARGER_CHGOK IOMUXC_GPIO_AD_B0_00_GPIO1_IO00
+#define PINUMX_BATTERY_CHARGER_ACOK  IOMUXC_GPIO_B1_06_GPIO2_IO22
+#define PINUMX_BATTERY_CHARGER_CHGEN IOMUXC_GPIO_B1_07_GPIO2_IO23
 
     void PINMUX_InitBatteryCharger(void);
 

@@ 0,0 1,137 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#include "battery-charger.hpp"
+#include "fsl_common.h"
+
+#include <board/BoardDefinitions.hpp>
+#include <EventStore.hpp>
+#include <drivers/gpio/DriverGPIO.hpp>
+
+namespace bsp::battery_charger
+{
+    namespace
+    {
+        std::shared_ptr<drivers::DriverGPIO> gpio;
+        std::shared_ptr<drivers::DriverGPIO> gpio_int;
+
+        static batteryRetval chargerStatus = batteryRetval::ChargerError;
+
+        xQueueHandle IRQQueueHandle = nullptr;
+
+    } // namespace
+
+    int init(xQueueHandle irqQueueHandle)
+    {
+        IRQQueueHandle = irqQueueHandle;
+
+        LOG_INFO("Initializing battery charger");
+
+        gpio = drivers::DriverGPIO::Create(
+            static_cast<drivers::GPIOInstances>(BoardDefinitions::BELL_BATTERY_CHARGER_GPIO),
+            drivers::DriverGPIOParams{});
+
+        drivers::DriverGPIOPinParams CHGENPinConfig;
+        CHGENPinConfig.dir      = drivers::DriverGPIOPinParams::Direction::Output;
+        CHGENPinConfig.irqMode  = drivers::DriverGPIOPinParams::InterruptMode::NoIntmode;
+        CHGENPinConfig.defLogic = 0;
+        CHGENPinConfig.pin      = static_cast<std::uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_CHGEN_PIN);
+        gpio->ConfPin(CHGENPinConfig);
+
+        drivers::DriverGPIOPinParams ACOKPinConfig;
+        ACOKPinConfig.dir      = drivers::DriverGPIOPinParams::Direction::Input;
+        ACOKPinConfig.irqMode  = drivers::DriverGPIOPinParams::InterruptMode::IntRisingOrFallingEdge;
+        ACOKPinConfig.defLogic = 0;
+        ACOKPinConfig.pin      = static_cast<std::uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_ACOK_PIN);
+        gpio->ConfPin(ACOKPinConfig);
+
+        gpio_int = drivers::DriverGPIO::Create(
+            static_cast<drivers::GPIOInstances>(BoardDefinitions::BELL_BATTERY_CHARGER_CHGOK_GPIO),
+            drivers::DriverGPIOParams{});
+
+        drivers::DriverGPIOPinParams CHGOKPinConfig;
+        CHGOKPinConfig.dir      = drivers::DriverGPIOPinParams::Direction::Input;
+        CHGOKPinConfig.irqMode  = drivers::DriverGPIOPinParams::InterruptMode::IntRisingOrFallingEdge;
+        CHGOKPinConfig.defLogic = 0;
+        CHGOKPinConfig.pin      = static_cast<std::uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_CHGOK_PIN);
+        gpio_int->ConfPin(CHGOKPinConfig);
+
+        // set mode to discharge initially
+        disableCharging();
+
+        /* Enable GPIO pin interrupt */
+        gpio_int->EnableInterrupt(1U << static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_CHGOK_PIN));
+        gpio->EnableInterrupt(1U << static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_ACOK_PIN));
+
+        enableCharging();
+        getChargeStatus();
+
+        return kStatus_Success;
+    }
+
+    void deinit()
+    {
+        gpio_int->DisableInterrupt(1 << static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_CHGOK_PIN));
+        gpio->DisableInterrupt(1 << static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_ACOK_PIN));
+
+        IRQQueueHandle = nullptr;
+
+        disableCharging();
+
+        gpio.reset();
+        gpio_int.reset();
+    }
+
+    bool getChargeStatus()
+    {
+        uint8_t acok  = gpio->ReadPin(static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_ACOK_PIN));
+        uint8_t chgok = gpio_int->ReadPin(static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_CHGOK_PIN));
+
+        LOG_DEBUG("Charger status ACOK[%u], CHGOK[%u]", acok, chgok);
+
+        if (acok != 0) {
+            chargerStatus                  = batteryRetval::ChargerNotCharging;
+            Store::Battery::modify().state = Store::Battery::State::Discharging;
+            LOG_INFO("Discharging battery");
+        }
+        else if ((chgok == 0) && (acok == 0)) {
+            chargerStatus                  = batteryRetval::ChargerCharging;
+            Store::Battery::modify().state = Store::Battery::State::Charging;
+            LOG_INFO("Charging battery");
+        }
+        else if ((chgok != 0) && (acok == 0)) {
+            chargerStatus                  = batteryRetval::ChargerComplete;
+            Store::Battery::modify().state = Store::Battery::State::ChargingDone;
+            LOG_INFO("Battery charging complete");
+        }
+
+        return ((chargerStatus == batteryRetval::ChargerCharging) || (chargerStatus == batteryRetval::ChargerComplete));
+    }
+
+    void setChargerError()
+    {
+        chargerStatus = batteryRetval::ChargerError;
+    }
+
+    void enableCharging()
+    {
+        LOG_INFO("Enable charging");
+        gpio->WritePin(static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_CHGEN_PIN), 0);
+    }
+
+    void disableCharging()
+    {
+        LOG_INFO("Disable charging");
+        gpio->WritePin(static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_CHGEN_PIN), 1);
+    }
+
+    BaseType_t CHG_IRQHandler()
+    {
+        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+
+        uint8_t val = 1;
+        xQueueSendFromISR(IRQQueueHandle, &val, &xHigherPriorityTaskWoken);
+
+        return xHigherPriorityTaskWoken;
+    }
+} // namespace bsp::battery_charger

@@ 0,0 1,43 @@
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
+// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
+
+#pragma once
+
+#include <cstdint>
+extern "C"
+{
+#include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
+}
+
+#include <array>
+
+namespace bsp::battery_charger
+{
+    using StateOfCharge = std::uint8_t;
+
+    enum class batteryRetval
+    {
+        ChargerError,
+        ChargerNotCharging,
+        ChargerCharging,
+        ChargerComplete,
+        ChargerStatus
+    };
+
+    int init(xQueueHandle irqQueueHandle);
+
+    void deinit();
+
+    bool getChargeStatus();
+
+    void setChargerError();
+
+    void enableCharging();
+
+    void disableCharging();
+
+    BaseType_t CHG_IRQHandler();
+
+} // namespace bsp::battery_charger

@@ 5,6 5,7 @@
 
 #include <hal/GenericFactory.hpp>
 #include <EventStore.hpp>
+#include <bsp/battery-charger/battery-charger.cpp>
 
 namespace hal::battery
 {


@@ 14,6 15,7 @@ namespace hal::battery
 
     void BatteryCharger::init(xQueueHandle queueBatteryHandle, xQueueHandle)
     {
+        bsp::battery_charger::init(queueBatteryHandle);
         // Mocking initial state to make system run
         Store::Battery::modify().state = Store::Battery::State::Discharging;
         Store::Battery::modify().level = getBatteryVoltage();


@@ 29,14 31,16 @@ namespace hal::battery
     {}
 
     void BatteryCharger::processStateChangeNotification(std::uint8_t notification)
-    {}
+    {
+        bsp::battery_charger::getChargeStatus();
+    }
 
     void BatteryCharger::setChargingCurrentLimit(std::uint8_t)
     {}
 
     BaseType_t IRQHandler()
     {
-        return 0;
+        return bsp::battery_charger::CHG_IRQHandler();
     }
 
     extern "C"

@@ 14,6 14,7 @@
 #include <hal/key_input/KeyInput.hpp>
 #include "board/BoardDefinitions.hpp"
 #include "bsp/light_sensor/light_sensor.hpp"
+#include <hal/battery_charger/BatteryCharger.hpp>
 
 namespace bsp
 {


@@ 65,6 66,10 @@ namespace bsp
             BaseType_t xHigherPriorityTaskWoken = 0;
             uint32_t irq_mask                   = GPIO_GetPinsInterruptFlags(GPIO1);
 
+            if (irq_mask & (1 << static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_CHGOK_PIN))) {
+                xHigherPriorityTaskWoken |= hal::battery::IRQHandler();
+            }
+
             // Clear all IRQs
             GPIO_PortClearInterruptFlags(GPIO1, irq_mask);
 


@@ 116,6 121,10 @@ namespace bsp
                 xHigherPriorityTaskWoken |= hal::key_input::generalIRQHandler(irq_mask);
             }
 
+            if (irq_mask & (1 << static_cast<uint32_t>(BoardDefinitions::BELL_BATTERY_CHARGER_ACOK_PIN))) {
+                xHigherPriorityTaskWoken |= hal::battery::IRQHandler();
+            }
+
             // Clear all IRQs
             GPIO_PortClearInterruptFlags(GPIO2, irq_mask);
 

@@ 1091,14 1091,14 @@ void PINMUX_InitEINK(void)
 
 void PINMUX_InitBatteryCharger(void)
 {
-    IOMUXC_SetPinMux(PINUMX_BATTERY_CHARGER_CHGINT,
+    IOMUXC_SetPinMux(PINUMX_BATTERY_CHARGER_CHGOK,
                      0U); /* Software Input On Field: Input Path is determined by functionality */
 
     IOMUXC_SetPinMux(PINUMX_BATTERY_CHARGER_ACOK, 0U);
 
     IOMUXC_SetPinMux(PINUMX_BATTERY_CHARGER_CHGEN, 0U);
 
-    IOMUXC_SetPinConfig(PINUMX_BATTERY_CHARGER_CHGINT,
+    IOMUXC_SetPinConfig(PINUMX_BATTERY_CHARGER_CHGOK,
 
                         PAD_CONFIG_SLEW_RATE_SLOW | PAD_CONFIG_DRIVER_DISABLED | PAD_CONFIG_SPEED_SLOW_50MHz |
                             PAD_CONFIG_PULL_KEEPER_DISABLED | PAD_CONFIG_SELECT_PULL | PAD_CONFIG_PULL_UP_100kOhm);