add main app skeleton

apps/fc/main_service/BUILD

@@ -0,0 +1,25 @@
+cc_binary(
+    name = "MainService",
+    srcs = [
+        "main.cc",
+        "mainService.cpp",
+        "mainService.hpp",
+        "service.hpp",
+        "rocket_state.h",
+        "rocketController.cpp",
+        "rocketController.hpp",
+    ],
+    visibility = [
+        "//deployment/apps/fc/main_app:__subpackages__"
+        ],
+    deps = [
+        "@srp_platform//ara/exec:adaptive_application_lib",
+        "@srp_platform//ara/diag:uds_lib",
+        "@srp_platform//ara/log",
+        "//core/common:condition_lib",
+        "//deployment/apps/fc/main_app:someip_lib",
+        "//deployment/apps/fc/main_app:ara",
+        "//core/common:common_types",
+        "//core/timestamp:timestamp_controller",
+    ],
+)

apps/fc/main_service/main.cc

@@ -0,0 +1,18 @@
+/**
+ * @file main.cc
+ * @author Mateusz Krajewski (matikrajek42@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2024-03-26
+ * 
+ * @copyright Copyright (c) 2024
+ * 
+ */
+#include "ara/exec/adaptive_lifecycle.h"
+#include "apps/fc/main_service/mainService.hpp"
+
+int main(int argc, char const *argv[]) {
+  // setsid();
+  return ara::exec::RunAdaptiveLifecycle<srp::service::MainService>(argc,
+                                                                     argv);
+}

apps/fc/main_service/mainService.cpp

@@ -0,0 +1,64 @@
+/**
+ * @file mainService.cpp
+ * @author Mateusz Krajewski (matikrajek42@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2025-04-14
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+#include <string>
+#include <unordered_map>
+#include <memory>
+#include <map>
+
+#include "ara/exec/adaptive_application.h"
+#include "apps/fc/main_service/service.hpp"
+#include "apps/fc/main_service/mainService.hpp"
+#include "core/common/condition.h"
+#include "apps/fc/main_service/rocket_state.h"
+namespace srp {
+namespace service {
+namespace {
+constexpr auto kService_ipc_name = "srp/apps/MainService/MainService_ipc";
+constexpr auto kService_udp_name = "srp/apps/RecoveryService/MainService_udp";
+using RocketState_t = apps::RocketState_t;
+const auto kMain_loop_delay_ms = 10;
+const auto kSend_event_time = 1000;
+}
+
+MainService::MainService() {}
+
+int MainService::Initialize(const std::map<ara::core::StringView, ara::core::StringView>
+                    parms) {
+    service_ipc = std::make_unique<apps::MyMainServiceSkeleton>(
+        ara::core::InstanceSpecifier(kService_ipc_name));
+    service_udp = std::make_unique<apps::MyMainServiceSkeleton>(
+        ara::core::InstanceSpecifier(kService_udp_name));
+    controller.Init();
+    return 0;
+}
+int MainService::Run(const std::stop_token& token) {
+    service_ipc->StartOffer();
+    service_udp->StartOffer();
+    auto last_send = std::chrono::high_resolution_clock::now();
+    auto state = apps::RocketState::GetInstance();
+    while (!token.stop_requested()) {
+        controller.Loop();
+        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::high_resolution_clock::now() - last_send);
+        if (elapsed.count() > kSend_event_time) {
+            auto val = static_cast<uint8_t>(state->GetState());
+            this->service_ipc->CurrentModeStatusEvent.Update(val);
+            this->service_udp->CurrentModeStatusEvent.Update(val);
+            last_send = std::chrono::high_resolution_clock::now();
+        }
+        core::condition::wait_for(std::chrono::milliseconds(kMain_loop_delay_ms), token);
+    }
+    service_ipc->StopOffer();
+    service_udp->StopOffer();
+    return 0;
+}
+}  // namespace service
+}  // namespace srp

apps/fc/main_service/mainService.hpp

@@ -0,0 +1,52 @@
+/**
+ * @file mainService.hpp
+ * @author Mateusz Krajewski (matikrajek42@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2025-04-14
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+#ifndef APPS_FC_MAIN_SERVICE_MAINSERVICE_HPP_
+#define APPS_FC_MAIN_SERVICE_MAINSERVICE_HPP_
+#include <string>
+#include <unordered_map>
+#include <memory>
+#include <map>
+
+#include "ara/exec/adaptive_application.h"
+#include "apps/fc/main_service/service.hpp"
+#include "apps/fc/main_service/rocket_state.h"
+#include "core/common/error_code.h"
+#include "apps/fc/main_service/rocketController.hpp"
+namespace srp {
+namespace service {
+class MainService final : public ara::exec::AdaptiveApplication {
+ private:
+  std::unique_ptr<apps::MyMainServiceSkeleton> service_ipc;
+  std::unique_ptr<apps::MyMainServiceSkeleton> service_udp;
+  apps::RocketController controller;
+ protected:
+  /**
+   * @brief This function is called to initialiaze the application
+   *
+   * @param parms map with parms
+   */
+  int Initialize(const std::map<ara::core::StringView, ara::core::StringView>
+                      parms) override;
+  /**
+   * @brief This function is called to launch the application
+   *
+   * @param token stop token
+   */
+  int Run(const std::stop_token& token) override;
+
+ public:
+  ~MainService() = default;
+  MainService();
+};
+
+}  // namespace service
+}  // namespace srp
+#endif  // APPS_FC_MAIN_SERVICE_MAINSERVICE_HPP_

apps/fc/main_service/rocketController.cpp

@@ -0,0 +1,120 @@
+/**
+ * @file rocketController.cpp
+ * @author Mateusz Krajewski (matikrajek42@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2025-04-14
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+#include "apps/fc/main_service/rocketController.hpp"
+#include "core/common/condition.h"
+namespace srp {
+namespace apps {
+namespace {
+    constexpr auto kCutdown_end_time_ms = 9500;
+    constexpr auto kLoss_conn_time_to_drop_fuel = 10000;
+    constexpr auto kPrimer_activation_delay_ms = 100;
+}
+RocketController::RocketController() {
+    rocket_state_ = apps::RocketState::GetInstance();
+    last_state_ = rocket_state_->GetState();
+    timestamp_.Init();
+}
+void RocketController::Loop() {
+  auto now_state = rocket_state_->GetState();
+  switch (now_state) {
+    case RocketState_t::INIT:
+    if (this->InitializeCompleted()) {
+        rocket_state_->SetState(RocketState_t::DISARM);
+    }
+    break;
+    case RocketState_t::DISARM:
+    break;
+    case RocketState_t::TANK:
+    if (last_state_ != RocketState_t::TANK) {
+        ActivateTankActuators();
+    }
+    break;
+    case RocketState_t::ARM:
+    if (last_state_ != RocketState_t::ARM) {
+        ArmRocket();
+    }
+    break;
+    case RocketState_t::CUTDOWN: {
+        static int start_timstamp;
+        if (last_state_ != RocketState_t::CUTDOWN) {
+            auto val_opt = timestamp_.GetNewTimeStamp();
+            if (val_opt.has_value()) {
+                start_timstamp = val_opt.value();
+            }
+            break;
+        }
+        auto now = timestamp_.GetNewTimeStamp();
+        if (!now.has_value()) {
+            break;
+        }
+        if (timestamp_.GetDeltaTime(now.value(), start_timstamp) >= kCutdown_end_time_ms) {
+            this->rocket_state_->SetState(RocketState_t::CUTDOWN_END);
+            break;
+        }
+    break;
+    }
+    case RocketState_t::CUTDOWN_END:
+    this->CutdownEndSeq();
+    this->rocket_state_->SetState(RocketState_t::FLIGHT);
+    break;
+    case RocketState_t::FLIGHT:
+    // TODO(simba) IDK thath we need something
+    break;
+    case RocketState_t::FALL:
+    if (last_state_ != RocketState_t::FALL) {
+        // TODO(simba) call Ref Parachute open
+        break;
+    }
+
+    break;
+    case RocketState_t::LANDED:
+    if (last_state_ != RocketState_t::LANDED) {
+        // TODO(simba) call Main Parachute open
+        // TODO(simba) open all actuator and disable power on actuator
+    }
+    break;
+    case RocketState_t::ABORD:
+        // TODO(simba) open vent valve
+        // TODO(simba) disable all actuator power
+    break;
+    case RocketState_t::LOST_CONN: {
+        // NOW UNUSED
+        // if (last_state_ != RocketState_t::LOST_CONN) {
+        //     LossConnSeq();
+        // }
+    break;
+    }
+}
+last_state_ = now_state;
+}
+
+core::ErrorCode RocketController::InitializeCompleted() {
+    return core::ErrorCode::kOk;
+}
+core::ErrorCode RocketController::ActivateTankActuators() {
+    return core::ErrorCode::kOk;
+}
+core::ErrorCode RocketController::ArmRocket() {
+    // enable power on all stages
+    return core::ErrorCode::kOk;
+}
+core::ErrorCode RocketController::CutdownEndSeq() {
+    // open main valve
+    std::this_thread::sleep_for(std::chrono::milliseconds(kPrimer_activation_delay_ms));
+    // activate primer
+    return core::ErrorCode::kOk;
+}
+core::ErrorCode RocketController::LossConnSeq() {
+    return core::ErrorCode::kOk;
+}
+
+}  // namespace apps
+}  // namespace srp

apps/fc/main_service/rocketController.hpp

@@ -0,0 +1,40 @@
+/**
+ * @file rocketController.hpp
+ * @author Mateusz Krajewski (matikrajek42@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2025-04-14
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+#ifndef APPS_FC_MAIN_SERVICE_ROCKETCONTROLLER_HPP_
+#define APPS_FC_MAIN_SERVICE_ROCKETCONTROLLER_HPP_
+#include <memory>
+#include "apps/fc/main_service/rocket_state.h"
+#include "core/common/error_code.h"
+#include "core/timestamp/timestamp_driver.hpp"
+namespace srp {
+namespace apps {
+
+class RocketController {
+ private:
+  std::shared_ptr<RocketState> rocket_state_;
+  apps::RocketState_t last_state_;
+  srp::core::timestamp::TimestampController timestamp_;
+  core::ErrorCode InitializeCompleted();
+  core::ErrorCode ActivateTankActuators();
+  core::ErrorCode ArmRocket();
+  core::ErrorCode CutdownEndSeq();
+  core::ErrorCode LossConnSeq();
+
+ public:
+  void Loop();
+  void Init() {}
+  RocketController();
+};
+
+}  // namespace apps
+}  // namespace srp
+
+#endif  // APPS_FC_MAIN_SERVICE_ROCKETCONTROLLER_HPP_

apps/fc/main_service/rocket_state.h

@@ -0,0 +1,61 @@
+/**
+ * @file rocket_state.h
+ * @author Mateusz Krajewski (matikrajek42@gmail.com)
+ * @brief 
+ * @version 0.1
+ * @date 2025-04-14
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+#ifndef APPS_FC_MAIN_SERVICE_ROCKET_STATE_H_
+#define APPS_FC_MAIN_SERVICE_ROCKET_STATE_H_
+#include <mutex>  // NOLINT
+#include <shared_mutex>
+#include <memory>
+#include <utility>
+namespace srp {
+namespace apps {
+class RocketState;
+static std::shared_ptr<RocketState> rocket_state = nullptr;
+
+enum RocketState_t {
+  INIT = 0,
+  DISARM = 1,
+  TANK = 2,
+  ARM = 3,
+  CUTDOWN = 4,
+  CUTDOWN_END = 5,
+  FLIGHT = 6,
+  FALL = 7,
+  LANDED = 8,
+  ABORD = 50,
+  LOST_CONN = 52
+};
+
+class RocketState {
+ private:
+  RocketState_t state_;
+  std::shared_mutex mtx_;
+ public:
+  static std::shared_ptr<RocketState> GetInstance() {
+    if (rocket_state == nullptr) {
+        rocket_state = std::make_shared<RocketState>();
+    }
+    return rocket_state;
+  }
+  RocketState_t GetState() {
+    std::shared_lock lock(mtx_);
+    return this->state_;
+  }
+  void SetState(const RocketState_t state) {
+    std::unique_lock lock(mtx_);
+    this->state_ = state;
+  }
+};
+
+
+}  // namespace apps
+}  // namespace srp
+
+#endif  // APPS_FC_MAIN_SERVICE_ROCKET_STATE_H_