XNSim/XNCore_Win/XNTimeManager/XNTimeManager.cpp

/**
 * @file XNTimeManager.cpp
 * @author	jinchao
 * @brief 时间管理器类源文件
 * @version	1.0
 * @date 2024-11-07
 *
 * @copyright Copyright (c) 2024 XN
 *
 */
#include "XNTimeManager.h"
#include "XNDDSManager/XNDDSManager.h"
#include "XNFramework/XNFramework.h"
#include "XNIDL/XNSimStatusPubSubTypes.hpp"
#include "XNThreadManager/XNThreadManager.h"
#include "XNTimeManager_p.h"


namespace XNSim {
XNTimeManager::XNTimeManager() : XNBaseFrameObject(new XNTimeManagerPrivate()) {
  SetUniqueId(enumValue(XNCoreObjectID::TimeManager));
  SetObjectName("XNTimeManager");
}

XNTimeManager::~XNTimeManager() {}

XNTimeManager::XNTimeManager(PrivateType *p) : XNBaseFrameObject(p) {}

std::chrono::system_clock::time_point XNTimeManager::GetSimTime() {
  T_D();
  XNThreadMutexLock(&(d->_mtx));
  auto simTime = d->_SimTime;
  XNThreadMutexUnlock(&(d->_mtx));
  return simTime;
}

void XNTimeManager::SetStartTime(const XN_TIMESPEC &simTime) {
  T_D();
// 将timespec转换为chrono::system_clock::time_point
#ifdef XN_WINDOWS
  auto duration =
      std::chrono::duration_cast<std::chrono::system_clock::duration>(
          std::chrono::seconds(simTime.QuadPart) +
          std::chrono::nanoseconds(simTime.QuadPart % 1000000000));
  d->_SimStartTime = std::chrono::system_clock::time_point(duration);
#endif
#ifdef XN_LINUX
  auto duration = std::chrono::seconds(simTime.tv_sec) +
                  std::chrono::nanoseconds(simTime.tv_nsec);
  d->_SimStartTime = std::chrono::system_clock::time_point(duration);
#endif
}

void XNTimeManager::Start() {
  T_D();
  if (d->_eRunStatus == RunStatus::NotStart) {
    LOG_INFO("XNSim Start!");
    d->_eRunStatus = RunStatus::Runing;
  } else {
    LOG_WARNING("XNSim Already Start!");
  }
}

void XNTimeManager::Abort() {
  T_D();
  if (d->_eRunStatus != RunStatus::Aborted) {
    LOG_INFO("XNSim Abort!");
    d->_eRunStatus = RunStatus::Aborted;
  } else {
    LOG_WARNING("XNSim Already Abort!");
  }
}

void XNTimeManager::Pause() {
  T_D();
  if (d->_eRunStatus == RunStatus::Runing) {
    LOG_INFO("XNSim Pause!");
    d->_eRunStatus = RunStatus::Suspend;
  } else {
    LOG_WARNING("XNSim is not in Runing status!");
  }
}

void XNTimeManager::Continue() {
  T_D();
  if (d->_eRunStatus == RunStatus::Suspend) {
    LOG_INFO("XNSim Continue!");
    d->_eRunStatus = RunStatus::Runing;
  } else {
    LOG_WARNING("XNSim is not in Pause status!");
  }
}

RunStatus XNTimeManager::GetStatus() {
  T_D();
  return d->_eRunStatus;
}

void XNTimeManager::SimControl(XN_UINT32 objectId, SimControlCmd cmd) {
  if (objectId == 0) {
    switch (cmd) {
    case SimControlCmd::Start:
      Start();
      break;
    case SimControlCmd::Abort:
      Abort();
      break;
    case SimControlCmd::Continue:
      Continue();
      break;
    case SimControlCmd::Suspend:
      Pause();
      break;
    }
  }
}

bool XNTimeManager::Initialize() {
  T_D();
  // 时间管理器线程初始化
  // XNThreadManager *threadManager = parent()->findChild<XNThreadManager
  // *>("XNThreadManager"); if (threadManager) { 	double dRunInter =
  // threadManager->GetBaseInter() * 32; 	d->_TimeManagerThread =
  // new XNThread(this, "TimeManagerThread", FreqLevel::ThirtyTwothFreq, 10, 0,
  // dRunInter); } else { 	d->_status = XNFrameObjectStatus::Unknown;
  // 	LOG_ERROR("XNTimeManager Initialize Failed!");
  // 	return;
  // }

  // d->_TimeManagerThread->AddFunction(std::bind(&XNTimeManager::StepExecute,
  // this),
  // FreqLevel::ThirtyTwothFreq, 0, 90);

  // connect(this, &XNTimeManager::SimControl, d->_TimeManagerThread,
  // &XNThread::OnSimControl); 运行状态初始化
  d->_eRunStatus =
      RunStatus::NotStart; // d->_TimeManagerThread->GetRunStatus();
  // 仿真时间初始化
  d->_SimTime = d->_SimStartTime;

  LOG_INFO("XNTimeManager Initialize Success!");
  d->_status = XNFrameObjectStatus::Initialized;
  return true;
}

bool XNTimeManager::PrepareForExecute() {
  T_D();
  d->_status = XNFrameObjectStatus::Ready;
  LOG_INFO("XNTimeManager is prepared!");
  return true;
}

void XNTimeManager::StepExecute() {
  T_D();
  // TODO 提交事件
  // 时间推进
  XNThreadMutexLock(&(d->_mtx));
  d->_SimTime +=
      std::chrono::microseconds(static_cast<int64_t>(BASE_RUN_INTER * 1.0E6));
  XNThreadMutexUnlock(&(d->_mtx));
}
} // namespace XNSim