Add Radio App to EC

apps/ec/radio_service/BUILD

@@ -0,0 +1,97 @@
+cc_binary(
+    name = "radio_service",
+    deps = [
+        "@srp_platform//ara/exec:adaptive_application_lib",
+        ":telemetry_provider",
+        ":someip_controller",
+        "//deployment/apps/radio_app:ara",
+        ":radio_controller",
+        "//core/timestamp:timestamp_controller",
+        "@srp_platform//ara/log",
+        "//apps/fc/main_service:MainService",
+        "//core/onTimerCallback:on_timer_callback_lib",
+    ],
+    srcs = [
+        "radio_app.cc",
+        "main.cc",
+        "gs_hb_guider.cpp",
+        "radio_app.h",
+        "gs_hb_guider.hpp",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "someip_controller",
+    srcs = [
+        "someip_controller.cpp",
+    ],
+    hdrs = [
+        "someip_controller.hpp",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@srp_platform//ara/log",
+        ":event_data",
+        "//deployment/apps/radio_app:someip_lib",
+        "//apps/fc/recovery_service:ParachuteController",
+        "//apps/ec/primer_service/controller:primer_controller",
+    ],
+)
+
+cc_library(
+    name = "radio_controller",
+    srcs = [
+        "radio_controller.cpp",
+    ],
+    hdrs = [
+        "radio_controller.hpp",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@srp_platform//ara/log",
+        ":event_data",
+        "@srp_mavlink//:simba_mavlink",
+        ":uart_driver",
+        "//core/common:wait_queue",
+    ],
+)
+
+cc_library(
+    name = "telemetry_provider",
+    srcs = [
+        "telemetry_provider.cpp",
+    ],
+    hdrs = [
+        "telemetry_provider.hpp",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@srp_mavlink//:simba_mavlink",
+        "@srp_platform//ara/log",
+        ":event_data",
+        "//core/timestamp:timestamp_controller",
+        "//apps/ec/primer_service/controller:primer_controller",
+    ],
+)
+
+cc_library(
+    name = "event_data",
+    hdrs = ["event_data.h"],
+    srcs = ["event_data.cc"],
+    deps = [
+        "@srp_mavlink//:simba_mavlink",
+        "//core/rocket_machine_state:rocket_state_base",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "uart_driver",
+    hdrs = ["mavlink_uart_driver.hpp"],
+    srcs = ["mavlink_uart_driver.cpp"],
+    deps = [
+        "//core/common:common_types",
+    ],
+    visibility = ["//visibility:public"],
+)

apps/ec/radio_service/event_data.cc

@@ -0,0 +1,185 @@
+/**
+ * @file event_data.cc
+ * @author Mateusz Krajewski (matikrajek42@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2026-02-28
+ * 
+ * @copyright Copyright (c) 2026
+ * 
+ */
+#include "apps/ec/radio_service/event_data.h"
+
+#include <algorithm>
+#include <numeric>
+
+namespace srp {
+namespace apps {
+namespace {
+    static std::shared_ptr<EventData> event_data = nullptr;
+}
+
+std::shared_ptr<EventData> EventData::GetInstance() {
+    if (event_data == nullptr) {
+        event_data = std::make_shared<EventData>();
+    }
+    return event_data;
+}
+
+  core::rocketState::RocketState_t EventData::GetComputerState(const BoardType_e BoardType) {
+    switch (BoardType) {
+      case BoardType_e::EB:
+        return EBState_.get();
+      case BoardType_e::MB:
+        return MBState_.get();
+      default:
+        return core::rocketState::RocketState_t::INIT;
+    }
+  }
+
+  void EventData::SetComputerState(const BoardType_e BoardType, const core::rocketState::RocketState_t state) {
+    switch (BoardType) {
+      case BoardType_e::EB:
+        EBState_.set(state);
+        break;
+      case BoardType_e::MB:
+        MBState_.set(state);
+        break;
+      default:
+        break;
+    }
+  }
+
+  uint8_t EventData::GetPrimerStates() {
+    return primer_state_.get();
+  }
+  void EventData::SetPrimerState(const uint8_t state) {
+    primer_state_.set(state);
+  }
+
+
+  uint8_t EventData::GetActuatorStates() {
+    return actuator_state_.get();
+  }
+  void EventData::SetActuatorState(const uint8_t actuator_mask, const uint8_t state) {
+    actuator_state_.update([&](uint8_t& current_mask) {
+      if (state) {
+        current_mask |= actuator_mask;
+      } else {
+        current_mask &= static_cast<uint8_t>(~actuator_mask);
+      }
+    });
+  }
+
+  computer_telemetry_t EventData::GetComputerTelemetry(const BoardType_e BoardType) {
+    if (BoardType == BoardType_e::EB) {
+      return eb_telemetry.get();
+    } else {
+      return mb_telemetry.get();
+    }
+  }
+  void EventData::SetComputerTemp(const BoardType_e BoardType, const uint8_t temp, const uint8_t index) {
+    if (index >= 3) {
+        return;
+    }
+    if (BoardType == BoardType_e::EB) {
+      eb_telemetry.update([&](auto& telemetry) {
+        telemetry.temps[index] = temp;
+      });
+    } else if (BoardType == BoardType_e::MB) {
+      mb_telemetry.update([&](auto& telemetry) {
+        telemetry.temps[index] = temp;
+      });
+    }
+  }
+  void EventData::SetComputerCpuUsage(const BoardType_e BoardType, const uint8_t cpu_usage) {
+    if (BoardType == BoardType_e::EB) {
+      eb_telemetry.update([&](auto& telemetry) {
+        telemetry.cpu_usage = cpu_usage;
+      });
+    } else if (BoardType == BoardType_e::MB) {
+      mb_telemetry.update([&](auto& telemetry) {
+        telemetry.cpu_usage = cpu_usage;
+      });
+    }
+  }
+  void EventData::SetComputerMemUsage(const BoardType_e BoardType, const uint8_t mem_usage) {
+    if (BoardType == BoardType_e::EB) {
+      eb_telemetry.update([&](auto& telemetry) {
+        telemetry.mem_usage = mem_usage;
+      });
+    } else if (BoardType == BoardType_e::MB) {
+      mb_telemetry.update([&](auto& telemetry) {
+        telemetry.mem_usage = mem_usage;
+      });
+    }
+  }
+
+  uint16_t EventData::GetTemp(const uint8_t index) {
+    if (index >= 3) {
+        return 0;
+    }
+    switch (index) {
+    case 0:
+        return tank_.get().lower_tank;
+    case 1:
+        return tank_.get().middle_tank;
+    case 2:
+        return tank_.get().upper_tank;
+    default:
+        return 0;
+    }
+  }
+  void EventData::SetTemp(const uint8_t index, const int16_t res) {
+    if (index >= 3) {
+        return;
+    }
+    tank_.update([&](auto& temp) {
+        switch (index) {
+        case 0:
+            temp.lower_tank = res;
+            break;
+        case 1:
+            temp.middle_tank = res;
+            break;
+        case 2:
+            temp.upper_tank = res;
+            break;
+        default:
+            break;
+        }
+    });
+  }
+
+  uint16_t EventData::GetPress() {
+    return tank_.get().pressure;
+  }
+  void EventData::SetPress(uint16_t res) {
+    tank_.update([&](auto& tank) {
+      tank.pressure = res;
+    });
+  }
+
+  mavlink_simba_gps_t EventData::GetGPS() {
+    return gps_.get();
+  }
+
+  void EventData::SetGPS(int32_t lon, int32_t lat, int32_t alt) {
+    mavlink_simba_gps_t gps_data;
+    gps_data.altitude = alt;
+    gps_data.lat = lat;
+    gps_data.lon = lon;
+    gps_.set(gps_data);
+  }
+
+  int32_t EventData::GetMaxAltitude() {
+    return max_altitude_.get().altitude;
+  }
+  void EventData::SetMaxAltitude(const int32_t alt) {
+    max_altitude_.update([&](auto& max_alt) {
+        max_alt.altitude = std::max(alt, max_alt.altitude);
+    });
+  }
+
+}  // namespace apps
+}  // namespace srp

apps/ec/radio_service/event_data.h

@@ -0,0 +1,103 @@
+/**
+ * @file event_data.h
+ * @author Michał Mańkowski (m.mankowski2004@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2025-05-07
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+#ifndef APPS_EC_RADIO_SERVICE_EVENT_DATA_H_
+#define APPS_EC_RADIO_SERVICE_EVENT_DATA_H_
+
+#include <shared_mutex>
+#include <mutex>  // NOLINT
+#include <memory>
+#include <cstdint>
+#include "simba/mavlink.h"
+#include "core/rocket_machine_state/rocket_state.hpp"
+
+namespace srp {
+namespace apps {
+
+template <typename T>
+class ThreadSafe {
+ public:
+    void set(const T& value) {
+        std::unique_lock lock(mtx_);
+        data_ = value;
+    }
+
+    T get() const {
+        std::shared_lock lock(mtx_);
+        return data_;
+    }
+
+    void update(std::function<void(T&)> func) {
+        std::unique_lock lock(mtx_);
+        func(data_);
+    }
+
+ private:
+    mutable std::shared_mutex mtx_;
+    T data_{};
+};
+
+enum class BoardType_e {EB, MB};
+
+struct computer_telemetry_t {
+    uint8_t temps[3];
+    uint8_t cpu_usage;
+    uint8_t mem_usage;
+};
+
+class EventData {
+ private:
+    ThreadSafe<mavlink_simba_tank_sensors_t> tank_;
+    ThreadSafe<mavlink_simba_gps_t> gps_;
+    ThreadSafe<mavlink_simba_imu_t> imu_;
+    ThreadSafe<mavlink_simba_max_altitude_t> max_altitude_;
+    ThreadSafe<uint8_t> actuator_state_;
+    ThreadSafe<uint8_t> primer_state_;
+
+    ThreadSafe<core::rocketState::RocketState_t> EBState_;
+    ThreadSafe<core::rocketState::RocketState_t> MBState_;
+
+    ThreadSafe<computer_telemetry_t> eb_telemetry;
+    ThreadSafe<computer_telemetry_t> mb_telemetry;
+
+ public:
+  static std::shared_ptr<EventData> GetInstance();
+
+  core::rocketState::RocketState_t GetComputerState(const BoardType_e BoardType);
+  void SetComputerState(const BoardType_e BoardType, const core::rocketState::RocketState_t state);
+
+  uint8_t GetPrimerStates();
+  void SetPrimerState(const uint8_t state);
+
+  uint8_t GetActuatorStates();
+  void SetActuatorState(const uint8_t actuator_mask, const uint8_t state);
+
+  uint16_t GetTemp(const uint8_t index);
+  void SetTemp(const uint8_t index, const int16_t res);
+
+  computer_telemetry_t GetComputerTelemetry(const BoardType_e BoardType);
+  void SetComputerTemp(const BoardType_e BoardType, const uint8_t temp, const uint8_t index);
+  void SetComputerCpuUsage(const BoardType_e BoardType, const uint8_t cpu_usage);
+  void SetComputerMemUsage(const BoardType_e BoardType, const uint8_t mem_usage);
+
+  uint16_t GetPress();
+  void SetPress(uint16_t res);
+
+  mavlink_simba_gps_t GetGPS();
+  void SetGPS(int32_t lon, int32_t lat, int32_t alt);
+
+  int32_t GetMaxAltitude();
+  void SetMaxAltitude(const int32_t alt);
+};
+
+}  // namespace apps
+}  // namespace srp
+
+#endif  // APPS_EC_RADIO_SERVICE_EVENT_DATA_H_