Method loop_infinite

OpenHD/ohd_telemetry/src/GroundTelemetry.cpp:199–250

}

void GroundTelemetry::loop_infinite(bool& terminate,
                                    const bool enableExtendedLogging) {
  const auto log_intervall = std::chrono::seconds(5);
  const auto loop_intervall = std::chrono::milliseconds(100);
  auto last_log = std::chrono::steady_clock::now();
  while (!terminate) {
    const auto loopBegin = std::chrono::steady_clock::now();
    if (std::chrono::steady_clock::now() - last_log >= log_intervall) {
      last_log = std::chrono::steady_clock::now();
      // m_console->debug("GroundTelemetry::loopInfinite()");
      //  for debugging, check if any of the endpoints is not alive
      if (enableExtendedLogging && m_wb_endpoint) {
        m_console->debug(m_wb_endpoint->createInfo());
      }
      if (enableExtendedLogging && m_gcs_endpoint) {
        m_console->debug(m_gcs_endpoint->createInfo());
      }
    }
    // send messages to the ground station in regular intervals, includes
    // heartbeat. everything else is handled by the callbacks and their threads
    {
      // NOTE: No component from the ground station ever needs to talk to the
      // air unit / FC itself
      std::lock_guard<std::mutex> guard(m_components_lock);
      for (auto& component : m_components) {
        assert(component);
        const auto messages = component->generate_mavlink_messages();
        send_messages_ground_station_clients(messages);
        // exception: timesync
        for (const auto& msg : messages) {
          if (msg.m.msgid == MAVLINK_MSG_ID_TIMESYNC) {
            m_console->debug("Sending timesync to air");
            send_messages_air_unit({msg});
          }
        }
      }
    }
    const auto loopDelta = std::chrono::steady_clock::now() - loopBegin;
    if (loopDelta > loop_intervall) {
      // We can't keep up with the wanted loop interval
      // We can't keep up with the wanted loop interval
      m_console->debug(
          "Warning GroundTelemetry cannot keep up with the wanted loop "
          "interval. Took {}",
          openhd::util::time_readable(loopDelta));
    } else {
      const auto sleepTime = loop_intervall - loopDelta;
      // send out in X second intervals
      std::this_thread::sleep_for(loop_intervall);
    }
  }
}

std::string GroundTelemetry::create_debug() const {
  std::stringstream ss;