Created a Macro class for easier use of macros

FluidNC/src/Machine/Macros.cpp

@@ -12,15 +12,14 @@ void MacroEvent::run(void* arg) {
  log_error("Macro can only be used in idle state");
  return;
  }
- log_debug("Macro " << n);
- config->_macros->run_macro(n);
+ config->_macros->_macro[n].run();
 }
 
-std::string Macros::_startup_line[n_startup_lines];
-std::string Macros::_macro[n_macros];
-std::string Macros::_after_homing_line;
-std::string Macros::_after_reset_line;
-std::string Macros::_after_unlock_line;
+Macro Macros::_startup_line[n_startup_lines] = { { "startup_line0" }, { "startup_line1" } };
+Macro Macros::_macro[n_macros] = { { "macro0" }, { "macro1" }, { "macro2" }, { "macro3" } };
+Macro Macros::_after_homing = { "after_homing" };
+Macro Macros::_after_reset = { "after_reset" };
+Macro Macros::_after_unlock = { "after_unlock" };
 
 MacroEvent macro0Event { 0 };
 MacroEvent macro1Event { 1 };
@@ -54,32 +53,29 @@ Cmd findOverride(std::string name) {
  return it == overrideCodes.end() ? Cmd::None : it->second;
 }
 
-bool Macros::run_macro(size_t n) {
- return run_macro(_macro[n]);
-}
-
-bool Macros::run_macro(const std::string& s) {
- if (s == "") {
+bool Macro::run() {
+ const std::string& s = _gcode;
+ if (_gcode == "") {
  return true;
  }
 
- log_info("Running macro: " << s);
+ log_info("Running macro " << _name << ": " << _gcode);
  char c;
- for (int i = 0; i < s.length(); i++) {
- c = s[i];
+ for (int i = 0; i < _gcode.length(); i++) {
+ c = _gcode[i];
  switch (c) {
  case '&':
  // & is a proxy for newlines in macros, because you cannot
  // enter a newline directly in a config file string value.
  WebUI::inputBuffer.push('\n');
  break;
  case '#':
- if ((i + 3) > s.length()) {
+ if ((i + 3) > _gcode.length()) {
  log_error("Missing characters after # realtime escape in macro");
  return false;
  }
  {
- std::string s1(s.c_str() + i + 1, 2);
+ std::string s1(_gcode.c_str() + i + 1, 2);
  Cmd cmd = findOverride(s1);
  if (cmd == Cmd::None) {
  log_error("Bad #xx realtime escape in macro");

FluidNC/src/Machine/Macros.h

@@ -24,39 +24,41 @@ extern MacroEvent macro2Event;
 extern MacroEvent macro3Event;
 
 namespace Machine {
+ class Macro {
+ public:
+ std::string _gcode;
+ std::string _name;
+ Macro(const char* name) : _name(name) {}
+ bool run();
+ };
+
  class Macros : public Configuration::Configurable {
  public:
  static const int n_startup_lines = 2;
  static const int n_macros = 4;
 
- private:
- static std::string _macro[n_macros];
-
- public:
- static std::string _startup_line[n_startup_lines];
- static std::string _after_homing_line;
- static std::string _after_reset_line;
- static std::string _after_unlock_line;
+ static Macro _macro[n_macros];
+ static Macro _startup_line[n_startup_lines];
+ static Macro _after_homing;
+ static Macro _after_reset;
+ static Macro _after_unlock;
 
  Macros() = default;
 
- bool run_macro(size_t index);
- bool run_macro(const std::string& s);
-
  // Configuration helpers:
 
  // TODO: We could validate the startup lines
 
  void group(Configuration::HandlerBase& handler) override {
- handler.item("startup_line0", _startup_line[0]);
- handler.item("startup_line1", _startup_line[1]);
- handler.item("macro0", _macro[0]);
- handler.item("macro1", _macro[1]);
- handler.item("macro2", _macro[2]);
- handler.item("macro3", _macro[3]);
- handler.item("after_homing", _after_homing_line);
- handler.item("after_reset", _after_reset_line);
- handler.item("after_unlock", _after_unlock_line);
+ handler.item(_startup_line[0]._name.c_str(), _startup_line[0]._gcode);
+ handler.item(_startup_line[1]._name.c_str(), _startup_line[1]._gcode);
+ handler.item(_macro[0]._name.c_str(), _macro[0]._gcode);
+ handler.item(_macro[1]._name.c_str(), _macro[1]._gcode);
+ handler.item(_macro[2]._name.c_str(), _macro[2]._gcode);
+ handler.item(_macro[3]._name.c_str(), _macro[3]._gcode);
+ handler.item(_after_homing._name.c_str(), _after_homing._gcode);
+ handler.item(_after_reset._name.c_str(), _after_reset._gcode);
+ handler.item(_after_unlock._name.c_str(), _after_unlock._gcode);
  }
 
  ~Macros() {}

FluidNC/src/ProcessSettings.cpp

@@ -290,7 +290,7 @@ static Error disable_alarm_lock(const char* value, WebUI::AuthenticationLevel au
  report_feedback_message(Message::AlarmUnlock);
  sys.state = State::Idle;
 
- config->_macros->run_macro(Macros::_after_unlock_line);
+ config->_macros->_after_unlock.run();
  } // Otherwise, no effect.
  return Error::Ok;
 }
@@ -329,7 +329,7 @@ static Error home(AxisMask axisMask) {
  protocol_execute_realtime();
  } while (sys.state == State::Homing);
 
- config->_macros->run_macro(Macros::_after_homing_line);
+ config->_macros->_after_homing.run();
 
  return Error::Ok;
 }
@@ -442,7 +442,7 @@ static Error get_report_build_info(const char* value, WebUI::AuthenticationLevel
 }
 static Error show_startup_lines(const char* value, WebUI::AuthenticationLevel auth_level, Channel& out) {
  for (int i = 0; i < config->_macros->n_startup_lines; i++) {
- log_to(out, "$N", i << "=" << config->_macros->_startup_line[i]);
+ log_to(out, "$N", i << "=" << config->_macros->_startup_line[i]._gcode);
  }
  return Error::Ok;
 }
@@ -597,9 +597,9 @@ static Error motors_init(const char* value, WebUI::AuthenticationLevel auth_leve
 
 static Error macros_run(const char* value, WebUI::AuthenticationLevel auth_level, Channel& out) {
  if (value) {
- log_info("Running macro " << *value);
+ log_info("Running macro" << *value);
  size_t macro_num = (*value) - '0';
- config->_macros->run_macro(macro_num);
+ config->_macros->_macro[macro_num].run();
  return Error::Ok;
  }
  log_error("$Macros/Run requires a macro number argument");
@@ -993,21 +993,7 @@ void settings_execute_startup() {
  }
  Error status_code;
  for (int i = 0; i < config->_macros->n_startup_lines; i++) {
- auto str = config->_macros->_startup_line[i];
- if (str.length()) {
- config->_macros->run_macro(str);
-#if 0
- // We have to copy this to a mutable array because
- // gc_execute_line modifies the line while parsing.
- char gcline[256];
- strncpy(gcline, str.c_str(), 255);
- status_code = gc_execute_line(gcline);
- // Uart0 << ">" << gcline << "\n";
- if (status_code != Error::Ok) {
- log_error("Startup line: " << errorString(status_code));
- }
-#endif
- }
+ config->_macros->_startup_line[i].run();
  }
 }
 

FluidNC/src/Protocol.cpp

@@ -388,7 +388,7 @@ static void protocol_do_restart() {
  send_alarm(ExecAlarm::ControlPin);
  } else {
  if (sys.state == State::Idle) {
- config->_macros->run_macro(Macros::_after_reset_line);
+ config->_macros->_after_reset.run();
  }
  }
 }