global.h

Go to the documentation of this file.

#pragma once
 
#ifdef WINDOWS_BUILD
#include <windows.h>
#endif
#include <atomic>
#include <csignal>
#include <filesystem>
#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;
 
// Port the standalone-autotuning HTTP server is started on and reached at.
extern uint16_t g_autotuning_port;
 
extern uint8 g_pIOmap[4096];
 
// SIGINT or SIGTERM caught
extern volatile sig_atomic_t g_sig_caught;
 
extern std::string g_driver_name;
 
enum class MasterType { kUnspecified, kMock, kSoem, kSpoe };
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;
 
// Requests a full re-enumeration of the EtherCAT bus from within the cyclic
// SOEM loop. The SOEM recovery path sets this when it detects that slaves
// dropped off the bus and returned (a power brown-out): such slaves lose their
// SyncManager/FMMU/PDO configuration and cannot be healed in place, so the
// machine manager's run loop watches this flag and escalates to the proven
// VirtualDeviceManager::init() re-enumeration (which also emits the
// DEINITIALIZING/INITIALIZING lifecycle events clients depend on). It is
// cleared once that stop()/init() sequence has been kicked off.
extern std::atomic<bool> g_reinitialization_required;
 
// Requests that the EtherCAT port be torn down and reopened (ec_close +
// ec_init) at the start of the next re-enumeration, instead of only re-running
// ec_config_init on the still-open port. Set by the SOEM init path when a
// reconnected slave reaches PRE-OP with an unresponsive mailbox: that wedged
// state lives in the open port and is cleared neither by ec_config_init nor by
// waiting (both were observed to loop indefinitely) - only by reopening the
// port, which is what a Motion Master process restart does. wait_for_slaves()
// consumes it, keeping it set until ec_init succeeds so a failed reopen
// retries.
extern std::atomic<bool> g_ethercat_port_reopen_required;
 
void g_soem_update_slavecount();
 
// Using Ethernet Master
extern std::vector<std::string> g_ethernet_ip_addresses;
extern std::string g_ethernet_pdo_mode;
 
// 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;
 
// Root directory for persistent user data (OD cache, etc.)
extern std::filesystem::path g_data_dir;

struct InternalLogger {
 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;
 
// Disable the in-memory cache of device files read over FoE. When true, every
// read_file() fetches fresh content from the device instead of serving a
// previously cached result.
extern bool g_disable_file_cache;
 
// Skip writing the custom PDO mapping (from 'ui.config.json') during slave
// initialization. When true, the device keeps whatever PDO mapping it already
// has and Motion Master simply reads it back. Useful when a device/firmware
// rejects the mapping SDO writes (wkc=0), which would otherwise leave monitored
// objects unmapped and force slow per-parameter SDO reads.
extern bool g_skip_pdo_mapping;
 
// Disable per-sample SDO polling of monitored parameters. When true, the
// background parameter refresher is never started, so monitoring serves only
// the values already in the PDO process image (which update every cycle for
// free); any monitored object that is NOT PDO-mapped holds the value it had at
// startup instead of being re-read. The refresher shares the single SOEM port
// with the cyclic process-data exchange, and on some firmware its SDO traffic
// starves that exchange and the process image freezes. Turning it off keeps the
// process data flowing cleanly at the cost of static non-PDO signals.
extern bool g_disable_sdo_polling;