Mima PCA9685 UT & improved adcsensor UT coverage

apps/ServoService/servoService.cpp

@@ -38,7 +38,8 @@ core::ErrorCode ServoService::Run(std::stop_token token) {
 core::ErrorCode ServoService::Initialize(
       const std::unordered_map<std::string, std::string>& parms) {
     //  this->servo_controller.Init(parms, std::make_unique<i2c::I2CController>());
-    this->servo_controller.Init(parms, std::make_unique<simba::i2c::I2CController>());
+    this->servo_controller.Init(parms, std::make_unique<simba::i2c::I2CController>(),
+      std::make_unique<gpio::GPIOController>());
     main_servo_status_event =
       std::make_shared<com::someip::EventSkeleton>("ServoApp/servoStatusEvent");
     vent_servo_status_event =

mw/gpio_server/controller/BUILD

@@ -7,9 +7,12 @@ cc_library(
         "//core/logger:Logger",
     ],
     srcs = ["gpio_controller.cpp"],
-    hdrs = ["gpio_controller.hpp"],
+    hdrs = [
+        "gpio_controller.hpp",
+        "Igpio_controller.h",
+        ],
     visibility = [
         "//apps:__subpackages__",
         "//mw:__subpackages__",
         ],
-)
+)

mw/gpio_server/controller/Igpio_controller.h

@@ -0,0 +1,26 @@
+/**
+ * @file Igpio_controller.h
+ * @author Michał Mańkowski (m.mankowski2004@gmail.com)
+ * @brief Interface for gpio controller
+ * @version 0.1
+ * @date 2024-06-16
+ * 
+ * @copyright Copyright (c) 2024
+ * 
+ */
+#ifndef MW_GPIO_SERVER_CONTROLLER_IGPIO_CONTROLLER_H_
+#define MW_GPIO_SERVER_CONTROLLER_IGPIO_CONTROLLER_H_
+#include <optional>
+#include "core/common/error_code.h"
+
+namespace simba {
+namespace gpio {
+class IGPIOController {
+ public:
+    virtual core::ErrorCode SetPinValue(uint8_t actuatorID, int8_t value) = 0;
+    virtual std::optional<int8_t> GetPinValue(uint8_t actuatorID) = 0;
+    virtual ~IGPIOController() = default;
+};
+}  // namespace gpio
+}  // namespace simba
+#endif  // MW_GPIO_SERVER_CONTROLLER_IGPIO_CONTROLLER_H_

mw/gpio_server/controller/gpio_controller.hpp

@@ -22,19 +22,20 @@
 #include "core/gpio/GPIO_digital_driver.h"
 #include "mw/gpio_server/data/header.hpp"
 #include "core/logger/Logger.h"
+#include "mw/gpio_server/controller/Igpio_controller.h"
 
 namespace simba {
 namespace gpio {
 
 
-class GPIOController {
+class GPIOController : public IGPIOController{
  private:
     std::unique_ptr<com::soc::ISocketStream> sock_;
  public:
     GPIOController() {}
     explicit GPIOController(std::unique_ptr<com::soc::ISocketStream> socket);
-    core::ErrorCode SetPinValue(uint8_t actuatorID, int8_t value);
-    std::optional<int8_t> GetPinValue(uint8_t actuatorID);
+    core::ErrorCode SetPinValue(uint8_t actuatorID, int8_t value) override;
+    std::optional<int8_t> GetPinValue(uint8_t actuatorID) override;
 };
 
 }  // namespace gpio

mw/gpio_server/controller/mock/BUILD

@@ -0,0 +1,12 @@
+cc_library(
+    name = "mock_gpio_controller",
+    srcs = [
+        "mock_gpio_controller.h",
+        ],
+    visibility = ["//visibility:public"],
+    deps=[
+        "@com_google_googletest//:gtest_main",
+        "//mw/gpio_server/controller:gpio_controller",
+    ],
+    testonly = True,
+)

mw/gpio_server/controller/mock/mock_gpio_controller.h

@@ -0,0 +1,25 @@
+/**
+ * @file mock_gpio_controller.h
+ * @author Michał Mańkowski (m.mankowski2004@gmail.com)
+ * @brief Mock gpio controller
+ * @version 0.1
+ * @date 2024-06-16
+ * 
+ * @copyright Copyright (c) 2024
+ * 
+ */
+#ifndef MW_GPIO_SERVER_CONTROLLER_MOCK_MOCK_GPIO_CONTROLLER_H_
+#define MW_GPIO_SERVER_CONTROLLER_MOCK_MOCK_GPIO_CONTROLLER_H_
+
+#include "gmock/gmock.h"
+#include "mw/gpio_server/controller/Igpio_controller.h"
+namespace simba {
+namespace mock {
+class MOCKGPIOController : public gpio::IGPIOController {
+ public:
+  MOCK_METHOD(core::ErrorCode, SetPinValue, (uint8_t actuatorID, int8_t value), (override));
+  MOCK_METHOD(std::optional<int8_t>, GetPinValue, (uint8_t actuatorID), (override));
+};
+}  // namespace mock
+}  // namespace simba
+#endif  // MW_GPIO_SERVER_CONTROLLER_MOCK_MOCK_GPIO_CONTROLLER_H_

mw/i2c_service/controller/Ii2c_controller.h

@@ -12,8 +12,9 @@
 #define MW_I2C_SERVICE_CONTROLLER_II2C_CONTROLLER_H_
 #include <vector>
 #include <optional>
+#include <memory>
 #include "mw/i2c_service/data/header.h"
-
+#include "communication-core/sockets/stream_ipc_socket.h"
 
 namespace simba {
 namespace i2c {
@@ -23,6 +24,7 @@ class II2CController{
                         uint8_t address, const std::vector<uint8_t>& payload) = 0;
 
  public:
+  virtual core::ErrorCode Init(std::unique_ptr<com::soc::StreamIpcSocket> socket) = 0;
   /**
    * @brief 
    * 

mw/i2c_service/controller/i2c_controller.h

@@ -31,7 +31,7 @@ class I2CController: public II2CController{
                         uint8_t address, const std::vector<uint8_t>& payload) override;
 
  public:
-  core::ErrorCode Init(std::unique_ptr<com::soc::StreamIpcSocket> socket);
+  core::ErrorCode Init(std::unique_ptr<com::soc::StreamIpcSocket> socket) override;
   /**
    * @brief 
    * 

mw/i2c_service/controller/mock/mock_i2ccontroller.h

@@ -14,6 +14,7 @@
 
 #include <vector>
 #include <optional>
+#include <memory>
 #include "gmock/gmock.h"
 #include "mw/i2c_service/controller/i2c_controller.h"
 
@@ -30,6 +31,7 @@ class MockI2CController : public i2c::II2CController {
         (const uint8_t address, const uint8_t reg, const uint8_t size), (override));
   MOCK_METHOD(std::optional<std::vector<uint8_t>>, WriteRead, (const uint8_t address,
         const uint8_t WriteData, const uint8_t ReadSize), (override));
+  MOCK_METHOD(core::ErrorCode, Init, (std::unique_ptr<com::soc::StreamIpcSocket> socket), (override));
 };
 }  // namespace mock
 }  // namespace simba

mw/i2c_service/controller/pca9685/controller.cpp

@@ -39,31 +39,50 @@ namespace {
 
 PCA9685::PCA9685() {
 }
-void PCA9685::Init(const std::unordered_map<std::string, std::string>& parms, std::unique_ptr<I2CController> i2c) {
-  this->i2c_ = std::move(i2c);
+core::ErrorCode PCA9685::Init(const std::unordered_map<std::string, std::string>& parms,
+ std::unique_ptr<II2CController> i2c, std::unique_ptr<gpio::IGPIOController> gpio) {
+  if (this->setI2C(std::move(i2c)) != core::ErrorCode::kOk || this->setGPIO(std::move(gpio)) != core::ErrorCode::kOk) {
+    AppLogger::Warning("Failed pointer assignment");
+    return core::ErrorCode::kInitializeError;
+  }
   this->i2c_->Init(std::make_unique<com::soc::StreamIpcSocket>());
   this->app_name = parms.at("app_name");
   std::string file_path = "/opt/"+this->app_name+"/etc/config.json";
   std::ifstream file(file_path);
   if (!file.is_open()) {
       AppLogger::Warning("Cant find file on path "+file_path);
-      return;
+      return core::ErrorCode::kInitializeError;;
   }
   nlohmann::json data = nlohmann::json::parse(file);
   auto db = this->ReadConfig(data);
   if (!db.has_value()) {
     AppLogger::Error("Servo config does not exist");
-    return;
+    return core::ErrorCode::kInitializeError;;
   }
   this->db_ = db.value();
   for (auto chan : this->db_) {
       this->SetServo(chan.second.channel, chan.second.off_pos);
   }
+  return core::ErrorCode::kOk;
+}
+core::ErrorCode PCA9685::setI2C(std::unique_ptr<II2CController> i2c) {
+  if (!i2c) {
+    return core::ErrorCode::kInitializeError;
+  }
+  this->i2c_ = std::move(i2c);
+  return core::ErrorCode::kOk;
+}
+core::ErrorCode PCA9685::setGPIO(std::unique_ptr<gpio::IGPIOController> gpio) {
+  if (!gpio) {
+    return core::ErrorCode::kInitializeError;
+  }
+  this->gpio_ = std::move(gpio);
+  return core::ErrorCode::kOk;
 }
 void PCA9685::MosfetFunc(const uint8_t &mosfet_id, const uint8_t &mosfet_time) {
-    this->gpio_.SetPinValue(mosfet_id, 1);
+    this->gpio_->SetPinValue(mosfet_id, 1);
     std::this_thread::sleep_for(std::chrono::milliseconds(mosfet_time));
-    this->gpio_.SetPinValue(mosfet_id, 0);
+    this->gpio_->SetPinValue(mosfet_id, 0);
 }
 
 core::ErrorCode PCA9685::AutoSetServoPosition(const uint8_t &actuator_id, const uint8_t &state) {

mw/i2c_service/controller/pca9685/controller.hpp

@@ -18,8 +18,10 @@
 #include <future> // NOLINT
 #include <memory>
 
+#include "mw/i2c_service/controller/Ii2c_controller.h"
 #include "mw/i2c_service/controller/i2c_controller.h"
 #include "mw/gpio_server/controller/gpio_controller.hpp"
+#include "mw/gpio_server/controller/Igpio_controller.h"
 #include "core/json/json_parser.h"
 namespace simba {
 namespace i2c {
@@ -40,18 +42,21 @@ struct Servo {
 
 class PCA9685 {
  private:
-  std::unique_ptr<I2CController> i2c_;
-  gpio::GPIOController gpio_;
+  std::unique_ptr<II2CController> i2c_;
+  std::unique_ptr<gpio::IGPIOController> gpio_;
   std::string app_name;
  protected:
   std::unordered_map<uint8_t, Servo> db_;
   std::optional<std::unordered_map<uint8_t, Servo>> ReadConfig(nlohmann::json data);
   core::ErrorCode SetServo(uint8_t channel, uint16_t pos);
   void MosfetFunc(const uint8_t &mosfet_id, const uint8_t &mosfet_time);
   std::vector<uint8_t> GenerateData(const uint8_t &channel, const uint16_t &pos);
+  core::ErrorCode setI2C(std::unique_ptr<II2CController> adc_);
+  core::ErrorCode setGPIO(std::unique_ptr<gpio::IGPIOController> gpio);
  public:
   PCA9685();
-  void Init(const std::unordered_map<std::string, std::string>& parms, std::unique_ptr<I2CController> i2c);
+  core::ErrorCode Init(const std::unordered_map<std::string, std::string>& parms, std::unique_ptr<II2CController> i2c,
+    std::unique_ptr<gpio::IGPIOController> gpio);
   core::ErrorCode AutoSetServoPosition(const uint8_t &actuator_id, const uint8_t &state);
   std::optional<uint8_t> ReadServoPosition(const uint8_t &actuator_id);
 };

mw/i2c_service/tests/BUILD

@@ -17,7 +17,9 @@ cc_test(
     visibility = ["//visibility:public"],
     deps=[
         "@com_google_googletest//:gtest_main",
-        "//mw/i2c_service/controller/pca9685:pca9685_controller"
+        "//mw/i2c_service/controller/pca9685:pca9685_controller",
+        "//mw/gpio_server/controller/mock:mock_gpio_controller",
+        "//mw/i2c_service/controller/mock:mock_i2c_controller",
     ],
 )
 cc_test(

mw/i2c_service/tests/test_adcsensor.cc

@@ -29,8 +29,8 @@ class TestWrapper : public simba::i2c::ADCSensorController {
     this->setConfig(db_);
   }
 
-  void TestSetPtr(std::unique_ptr<simba::mock::MockADS7828> adc_) {
-    this->setPtr(std::move(adc_));
+  simba::core::ErrorCode TestSetPtr(std::unique_ptr<simba::i2c::IADS7828> adc_) {
+    return this->setPtr(std::move(adc_));
   }
 };
 
@@ -85,7 +85,86 @@ INSTANTIATE_TEST_SUITE_P(TestReadConfigParams, TestReadConfig, ::testing::Values
             "a": 100,
             "b": -20
         }
-        ]})", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{{10, {0x1, 123, -12}}, {11, {0x2, 100, -20}}})
+        ]})", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{{10, {0x1, 123, -12}}, {11, {0x2, 100, -20}}}),
+    std::make_tuple(R"({  })", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{}),
+    std::make_tuple(R"({
+    "sensors": [
+    ]
+    })", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{}),
+    std::make_tuple(R"({
+    "sensors": [
+        {
+            "actuator_id": 11,
+            "channel": 2,
+            "R": 150,
+            "RES_MIN":0,
+            "RES_MAX":0.3,
+            "A_MIN": 4,
+            "A_MAX": 20
+        }
+        ]})", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{{11, {0x2, 0.125, -0.075}}}),
+    std::make_tuple(R"({
+    "sensors": [
+        {
+            "actuator_id": 11,
+            "channel": 2,
+            "R": 150,
+            "RES_MAX":0.3,
+            "A_MIN": 4,
+            "A_MAX": 20
+        }
+        ]})", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{}),
+    std::make_tuple(R"({
+    "sensors": [
+        {
+            "actuator_id": 11,
+            "channel": 2,
+            "R": 150,
+            "RES_MIN":0,
+            "A_MIN": 4,
+            "A_MAX": 20
+        }
+        ]})", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{}),
+    std::make_tuple(R"({
+    "sensors": [
+        {
+            "actuator_id": 11,
+            "channel": 2,
+            "RES_MIN"0:,
+            "RES_MAX":0.3,
+            "A_MIN": 4,
+            "A_MAX": 20
+        }
+        ]})", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{}),
+    std::make_tuple(R"({
+    "sensors": [
+        {
+            "actuator_id": 11,
+            "channel": 2,
+            "R": 150,
+            "RES_MIN":0,
+            "RES_MAX":0.3,
+            "A_MAX": 20
+        }
+        ]})", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{}),
+    std::make_tuple(R"({
+    "sensors": [
+        {
+            "actuator_id": 11,
+            "channel": 2,
+            "R": 150,
+            "RES_MIN":0,
+            "RES_MAX":0.3,
+            "A_MIN": 4
+        }
+        ]})", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{}),
+    std::make_tuple(R"({
+    "sensors": [
+        {
+            "actuator_id": 11,
+            "channel": 2
+        }
+        ]})", std::unordered_map<uint8_t, simba::i2c::SensorConfig>{})
 ));
 
 TEST_P(TestReadConfig, ReadConfigCheck) {
@@ -112,11 +191,15 @@ class TestGetValue : public ::testing::TestWithParam<std::tuple<std::unordered_m
 // tuple<config, sensor_id, mockAdcVoltage, expectedResult>
 INSTANTIATE_TEST_SUITE_P(TestGetValueParams, TestGetValue, ::testing::Values(
   std::make_tuple(std::unordered_map<uint8_t, simba::i2c::SensorConfig>
-  {{10, {1, 123, -12}}, {11, {1, 100, -20}}}, 11, std::optional<float>{3.2}, std::optional<float>{300}),
+    {{10, {1, 123, -12}}, {11, {1, 100, -20}}}, 11, std::optional<float>{3.2}, std::optional<float>{300}),
+  std::make_tuple(std::unordered_map<uint8_t, simba::i2c::SensorConfig>
+    {{10, {1, 123, -12}}, {11, {1, 100, -20}}}, 11, std::optional<float>{1}, std::optional<float>{80}),
   std::make_tuple(std::unordered_map<uint8_t, simba::i2c::SensorConfig>
-  {{10, {1, 123, -12}}, {11, {1, 100, -20}}}, 11, std::optional<float>{1}, std::optional<float>{80}),
+    {{1, {10, 200, -40}}}, 1, std::optional<float>{3.2}, std::optional<float>{600}),
+  std::make_tuple(std::unordered_map<uint8_t, simba::i2c::SensorConfig>{
+    }, 1, std::optional<float>{3.2}, std::optional<float>{}),
   std::make_tuple(std::unordered_map<uint8_t, simba::i2c::SensorConfig>
-  {{1, {10, 200, -40}}}, 1, std::optional<float>{3.2}, std::optional<float>{600})
+    {{1, {10, 200, -40}}}, 1, std::optional<float>{}, std::optional<float>{})
 ));
 
 TEST_P(TestGetValue, GetValueCheck) {
@@ -135,3 +218,10 @@ TEST_P(TestGetValue, GetValueCheck) {
     wrapper.TestSetPtr(std::move(mock_adc_));
     EXPECT_EQ(wrapper.GetValue(sensor_id), expectedResult);
 }
+
+TEST(TestADCSensor, SetPtrTest) {
+    TestWrapper wrapper{};
+    auto adc = std::make_unique<simba::i2c::ADS7828>();
+    EXPECT_EQ(wrapper.TestSetPtr(nullptr), simba::core::ErrorCode::kInitializeError);
+    EXPECT_EQ(wrapper.TestSetPtr(std::move(adc)), simba::core::ErrorCode::kOk);
+}