🚸 (battery): Charge input as InterruptIn

app/bootloader/main.cpp

@@ -7,7 +7,7 @@
 #include "mbed_application.h"
 #include "mbedtls/platform.h"
 
-#include "drivers/DigitalIn.h"
+#include "drivers/InterruptIn.h"
 #include "rtos/ThisThread.h"
 
 #include "CoreBattery.h"
@@ -19,7 +19,7 @@ using namespace leka;
 
 constexpr auto default_address = uint32_t {0x8040000 + 0x1000};	  // Start application address + header
 
-static auto charge_status_input = mbed::DigitalIn {PinName::BATTERY_CHARGE_STATUS};
+static auto charge_status_input = mbed::InterruptIn {PinName::BATTERY_CHARGE_STATUS};
 static auto battery				= leka::CoreBattery {PinName::BATTERY_VOLTAGE, charge_status_input};
 
 auto main() -> int

drivers/CoreBattery/include/CoreBattery.h

@@ -6,7 +6,8 @@
 #define _LEKA_OS_DRIVER_CORE_BATTERY_H_
 
 #include "drivers/AnalogIn.h"
-#include "drivers/interfaces/InterfaceDigitalIn.h"
+#include "drivers/InterruptIn.h"
+#include "platform/Callback.h"
 
 #include "interface/drivers/Battery.h"
 
@@ -15,10 +16,13 @@ namespace leka {
 class CoreBattery : public interface::Battery
 {
   public:
-	explicit CoreBattery(PinName voltage_pin, mbed::interface::DigitalIn &charge_status_input)
+	explicit CoreBattery(PinName voltage_pin, mbed::InterruptIn &charge_status_input)
 		: _voltage_pin {mbed::AnalogIn(voltage_pin, analog_voltage_reference)},
 		  _charge_status_input(charge_status_input) {};
 
+	void onChargeDidStart(mbed::Callback<void()> const &callback);
+	void onChargeDidStop(mbed::Callback<void()> const &callback);
+
 	auto voltage() -> float final;
 	auto level() -> uint8_t final;
 	auto isCharging() -> bool final;
@@ -45,7 +49,7 @@ class CoreBattery : public interface::Battery
 	[[nodiscard]] auto convertToRealVoltage(float value) const -> float;
 
 	mbed::AnalogIn _voltage_pin;
-	mbed::interface::DigitalIn &_charge_status_input;
+	mbed::InterruptIn &_charge_status_input;
 };
 
 }	// namespace leka

drivers/CoreBattery/source/CoreBattery.cpp

@@ -8,6 +8,16 @@
 
 namespace leka {
 
+void CoreBattery::onChargeDidStart(mbed::Callback<void()> const &callback)
+{
+	_charge_status_input.rise(callback);
+}
+
+void CoreBattery::onChargeDidStop(mbed::Callback<void()> const &callback)
+{
+	_charge_status_input.fall(callback);
+}
+
 auto CoreBattery::voltage() -> float
 {
 	auto raw_average = getAverageVoltage();

drivers/CoreBattery/tests/CoreBattery_test.cpp

@@ -5,13 +5,11 @@
 #include "CoreBattery.h"
 
 #include "gtest/gtest.h"
-#include "mocks/mbed/DigitalIn.h"
 #include "stubs/mbed/AnalogIn.h"
+#include "stubs/mbed/InterruptIn.h"
 
 using namespace leka;
 
-using ::testing::Return;
-
 class CoreBatteryTest : public ::testing::Test
 {
   protected:
@@ -20,7 +18,7 @@ class CoreBatteryTest : public ::testing::Test
 	// void SetUp() override {}
 	// void TearDown() override {}
 
-	mbed::mock::DigitalIn charge_input = {};
+	mbed::InterruptIn charge_input = {NC};
 
 	CoreBattery battery;
 };
@@ -106,16 +104,46 @@ TEST_F(CoreBatteryTest, voltageBelowEmpty)
 	ASSERT_EQ(battery.level(), expected_battery_level);
 }
 
+TEST_F(CoreBatteryTest, onChargeDidStart)
+{
+	auto lambda_dummy	 = []() {};
+	auto lambda_impostor = []() {};
+
+	mbed::Callback<void()> callback_dummy(lambda_dummy);
+	mbed::Callback<void()> callback_impostor(lambda_impostor);
+
+	battery.onChargeDidStart(callback_dummy);
+
+	ASSERT_NE(callback_impostor, callback_dummy);
+	ASSERT_NE(callback_impostor, spy_InterruptIn_getRiseCallback());
+	ASSERT_EQ(callback_dummy, spy_InterruptIn_getRiseCallback());
+}
+
+TEST_F(CoreBatteryTest, onChargeDidStop)
+{
+	auto lambda_dummy	 = []() {};
+	auto lambda_impostor = []() {};
+
+	mbed::Callback<void()> callback_dummy(lambda_dummy);
+	mbed::Callback<void()> callback_impostor(lambda_impostor);
+
+	battery.onChargeDidStop(callback_dummy);
+
+	ASSERT_NE(callback_impostor, callback_dummy);
+	ASSERT_NE(callback_impostor, spy_InterruptIn_getFallCallback());
+	ASSERT_EQ(callback_dummy, spy_InterruptIn_getFallCallback());
+}
+
 TEST_F(CoreBatteryTest, isCharging)
 {
-	EXPECT_CALL(charge_input, read).WillOnce(Return(1));
+	spy_InterruptIn_setValue(1);
 
 	ASSERT_TRUE(battery.isCharging());
 }
 
 TEST_F(CoreBatteryTest, isNotCharging)
 {
-	EXPECT_CALL(charge_input, read).WillOnce(Return(0));
+	spy_InterruptIn_setValue(0);
 
 	ASSERT_FALSE(battery.isCharging());
 }

spikes/lk_sensors_battery/main.cpp

@@ -3,11 +3,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "drivers/BufferedSerial.h"
-#include "drivers/DigitalIn.h"
+#include "drivers/DigitalOut.h"
+#include "drivers/InterruptIn.h"
 #include "rtos/ThisThread.h"
 
 #include "CoreBattery.h"
-#include "HelloWorld.h"
 #include "LogKit.h"
 
 using namespace leka;
@@ -17,13 +17,19 @@ auto main() -> int
 {
 	logger::init();
 
-	auto charge_input = mbed::DigitalIn {PinName::BATTERY_CHARGE_STATUS};
-	auto corebattery  = leka::CoreBattery {PinName::BATTERY_VOLTAGE, charge_input};
+	auto charge_input  = mbed::InterruptIn {PinName::BATTERY_CHARGE_STATUS};
+	auto corebattery   = leka::CoreBattery {PinName::BATTERY_VOLTAGE, charge_input};
+	auto mainboard_led = mbed::DigitalOut {LED1};
 
 	log_info("Hello, World!\n\n");
 
-	HelloWorld hello;
-	hello.start();
+	mainboard_led.write(corebattery.isCharging());
+
+	auto on_charge_on = [&mainboard_led]() { mainboard_led.write(1); };
+	corebattery.onChargeDidStart(on_charge_on);
+
+	auto on_charge_off = [&mainboard_led]() { mainboard_led.write(0); };
+	corebattery.onChargeDidStop(on_charge_off);
 
 	while (true) {
 		if (corebattery.isCharging()) {

tests/unit/stubs/CMakeLists.txt

@@ -17,6 +17,7 @@ target_sources(stubs
 	INTERFACE
 		${UNIT_TESTS_STUBS_MBED_DIR}/source/gpio_api.cpp
 		${UNIT_TESTS_STUBS_MBED_DIR}/source/AnalogIn.cpp
+		${UNIT_TESTS_STUBS_MBED_DIR}/source/InterruptIn.cpp
 		${UNIT_TESTS_STUBS_MBED_DIR}/source/PwmOut.cpp
 		${UNIT_TESTS_STUBS_MBED_DIR}/source/QSPI.cpp
 		${UNIT_TESTS_STUBS_MBED_DIR}/source/I2C.cpp

tests/unit/stubs/stubs/mbed/InterruptIn.h

@@ -0,0 +1,17 @@
+// Leka - LekaOS
+// Copyright 2022 APF France handicap
+// SPDX-License-Identifier: Apache-2.0
+
+#include "drivers/InterruptIn.h"
+
+namespace leka {
+
+extern int spy_InterruptIn_value;
+extern mbed::Callback<void()> spy_InterruptIn_risecallback;
+extern mbed::Callback<void()> spy_InterruptIn_fallcallback;
+
+void spy_InterruptIn_setValue(int value);
+auto spy_InterruptIn_getRiseCallback() -> mbed::Callback<void()>;
+auto spy_InterruptIn_getFallCallback() -> mbed::Callback<void()>;
+
+}	// namespace leka

tests/unit/stubs/stubs/mbed/source/InterruptIn.cpp

@@ -0,0 +1,56 @@
+// Leka - LekaOS
+// Copyright 2022 APF France handicap
+// SPDX-License-Identifier: Apache-2.0
+
+#include "../InterruptIn.h"
+
+// SingletonPtr<PlatformMutex> mbed::InterruptIn::_mutex;
+
+namespace mbed {
+
+InterruptIn::InterruptIn(PinName pin)
+{
+	// nothing to do
+}
+
+InterruptIn::~InterruptIn() = default;
+
+auto InterruptIn::read() -> int
+{
+	return leka::spy_InterruptIn_value;
+}
+
+void InterruptIn::rise(Callback<void()> func)
+{
+	leka::spy_InterruptIn_risecallback = func;
+}
+
+void InterruptIn::fall(Callback<void()> func)
+{
+	leka::spy_InterruptIn_fallcallback = func;
+}
+
+}	// namespace mbed
+
+namespace leka {
+
+int spy_InterruptIn_value = -42.0;
+mbed::Callback<void()> spy_InterruptIn_risecallback {};
+mbed::Callback<void()> spy_InterruptIn_fallcallback {};
+
+void spy_InterruptIn_setValue(int value)
+{
+	spy_InterruptIn_value = value;
+}
+
+auto spy_InterruptIn_getRiseCallback() -> mbed::Callback<void()>
+{
+	return spy_InterruptIn_risecallback;
+}
+
+auto spy_InterruptIn_getFallCallback() -> mbed::Callback<void()>
+{
+	return spy_InterruptIn_fallcallback;
+}
+
+}	// namespace leka