global.h

Go to the documentation of this file.

#pragma once
 
#ifdef WINDOWS_BUILD
#include <windows.h>
#endif
#include <atomic>
#include <csignal>
#include <iostream>
#include <map>
#include <mutex>
#include <queue>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>
 
#include "ethercat.h"
#include "loguru.h"
#include "standalone_autotuning.h"
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
extern StandaloneAutotuning g_standalone_autotuning;
 
extern uint8 g_pIOmap[4096];
 
// SIGINT or SIGTERM caught
extern volatile sig_atomic_t g_sig_caught;
 
enum class MasterType { kUnspecified, kIgh, kMock, kSoem, kEthernet };
extern MasterType g_master_type;
 
extern uint16_t g_req_res_port;
extern uint16_t g_pub_sub_port;
 
extern std::atomic<int> g_slavecount;
 
// Using SOEM
extern std::string g_soem_mac_address;
extern std::string g_soem_ifname;
extern std::vector<std::recursive_mutex> g_soem_mailbox_mutexes;
extern std::atomic<bool> g_pdo_mapping_in_progress;
 
void g_soem_update_slavecount();
 
// Using Ethernet Master
extern std::vector<std::string> g_ethernet_ip_addresses;
 
// Number of mocked devices
extern size_t g_mock_devices;
 
// Path to a directory holding the templates for mock devices
extern std::string g_templates_path;
 
struct InternalLogger {
 public:
 private:
  static std::map<std::string, std::unique_ptr<InternalLogger>> self_map;
  constexpr static std::uint32_t internal_log_size = 0x200000;
  std::mutex internal_log_mutex;
  uint32_t type;
  std::string name;
 
 public:
  std::string g_internal_log;
  std::string g_internal_log_copy;
  std::vector<std::string> logPreVec;
  std::vector<std::string> logMsgVec;
  std::vector<std::string> logIndVec;
  std::deque<std::string> assertEqStrQue;
  std::deque<void*> assertEqUserDataQue;
  bool m_pop;
  void (*assertEqCallback)(const std::string& pre, const std::string& str1,
                           const std::string& str2, void* userData,
                           int& retval);
 
  static InternalLogger* getInstance(const std::string& name) {
    if (InternalLogger::self_map.find(name) == InternalLogger::self_map.end()) {
      InternalLogger::self_map.insert(
          {name, std::make_unique<InternalLogger>()});
      InternalLogger::self_map.at(name).get()->name = name;
      InternalLogger::self_map.at(name).get()->type = 0;
      InternalLogger::self_map.at(name).get()->assertEqCallback = nullptr;
      InternalLogger::self_map.at(name).get()->m_pop = true;
    }
    return InternalLogger::self_map.at(name).get();
  }
 
  static void setType(const std::string& name, uint32_t type) {
    InternalLogger::self_map.at(name).get()->type = type;
  }
 
  void log(const loguru::Message& message) {
    std::unique_lock<std::mutex> lk(internal_log_mutex);
    if (type == 0) {
      g_internal_log += message.preamble;
      g_internal_log += message.indentation;
      g_internal_log += message.message;
      g_internal_log += "\n";
      if (g_internal_log.size() > internal_log_size) {
        // Erase the first 12.5% of the internal log
        auto pos = g_internal_log.find_first_of('\n', internal_log_size >> 3u);
        g_internal_log.erase(0, pos + 1);
      }
    } else if (type == 1) {
      logPreVec.push_back(message.preamble);
      logMsgVec.push_back(message.message);
      logIndVec.push_back(message.indentation);
      if (!assertEqStrQue.empty()) {
        if (assertEqCallback != nullptr) {
          size_t loopSize = assertEqStrQue.size();
          for (size_t i = 0; i < loopSize; i++) {
            int retval = 0;
            (*assertEqCallback)(logPreVec.back(), logMsgVec.back(),
                                assertEqStrQue.at(i), assertEqUserDataQue.at(i),
                                retval);
            if (retval != 0) {
              assertEqStrQue.clear();
              assertEqUserDataQue.clear();
              break;
            }
            if (m_pop) {
              assertEqStrQue.pop_front();
              assertEqUserDataQue.pop_front();
            }
          }
        }
      }
    }
  }
 
  static std::string& get_log(const std::string& name) {
    InternalLogger* pil = InternalLogger::getInstance(name);
    std::unique_lock<std::mutex> lk(pil->internal_log_mutex);
    pil->g_internal_log_copy = pil->g_internal_log;
    return pil->g_internal_log_copy;
  }
 
  static void log_to_internal_log(void* user_data,
                                  const loguru::Message& message) {
    reinterpret_cast<InternalLogger*>(user_data)->log(message);
  }
 
  void setAssertEqCallback(void (*func)(const std::string& pre,
                                        const std::string& str1,
                                        const std::string& str2, void* userData,
                                        int& retval)) {
    assertEqCallback = func;
  }
 
  void pushAssertEq(const std::string& str, void* userData = nullptr) {
    assertEqStrQue.push_front(str);
    assertEqUserDataQue.push_front(userData);
  }
 
  void setPop() { m_pop = true; }
  void clearPop() { m_pop = false; }
 
  void resetState() {
    g_internal_log.clear();
    g_internal_log_copy.clear();
    logPreVec.clear();
    logMsgVec.clear();
    logIndVec.clear();
    assertEqStrQue.clear();
    assertEqUserDataQue.clear();
  }
};
 
// Motion Master running in end of the line testing mode
extern bool g_eol_mode;