Added shared_fault_pin for stopping on driver faults/stalls

FluidNC/src/Machine/Axes.cpp

@@ -37,6 +37,12 @@ namespace Machine {
  _sharedStepperReset.report("Shared stepper reset");
  }
 
+ if (_sharedFaultPin.defined()) {
+ _faultPin = new FaultPin(_sharedFaultPin);
+ _faultPin->init();
+ }
+
+
  // certain motors need features to be turned on. Check them here
  for (size_t axis = X_AXIS; axis < _numberAxis; axis++) {
  auto a = _axis[axis];
@@ -189,6 +195,7 @@ namespace Machine {
  void Axes::group(Configuration::HandlerBase& handler) {
  handler.item("shared_stepper_disable_pin", _sharedStepperDisable);
  handler.item("shared_stepper_reset_pin", _sharedStepperReset);
+ handler.item("shared_fault_pin", _sharedFaultPin);
 
  // Handle axis names xyzabc. handler.section is inferred
  // from a template.

FluidNC/src/Machine/Axes.h

@@ -7,6 +7,7 @@
 #include "../Configuration/Configurable.h"
 #include "Axis.h"
 #include "../EnumItem.h"
+#include "src/Machine/FaultPin.h"
 
 namespace MotorDrivers {
  class MotorDriver;
@@ -16,6 +17,8 @@ namespace Machine {
  class Axes : public Configuration::Configurable {
  bool _switchedStepper = false;
 
+ Pin _sharedFaultPin;
+
  public:
  static constexpr const char* _names = "XYZABC";
 
@@ -28,14 +31,16 @@ namespace Machine {
  static MotorMask limitMask;
  static MotorMask motorMask;
 
+ Pin _sharedStepperDisable;
+ Pin _sharedStepperReset;
+
  inline char axisName(int index) { return index < MAX_N_AXIS ? _names[index] : '?'; } // returns axis letter
 
  static inline size_t motor_bit(size_t axis, size_t motor) { return motor ? axis + 16 : axis; }
  static inline AxisMask motors_to_axes(MotorMask motors) { return (motors & 0xffff) | (motors >> 16); }
  static inline MotorMask axes_to_motors(AxisMask axes) { return axes | (axes << 16); }
 
- Pin _sharedStepperDisable;
- Pin _sharedStepperReset;
+ FaultPin* _faultPin = nullptr;
 
  int _numberAxis = 0;
  Axis* _axis[MAX_N_AXIS];

FluidNC/src/Machine/FaultPin.cpp

@@ -0,0 +1,9 @@
+#include "src/Machine/FaultPin.h"
+#include "src/Machine/MachineConfig.h" // config
+
+#include "src/MotionControl.h" // mc_reset
+#include "src/Protocol.h" // protocol_send_event_from_ISR()
+
+namespace Machine {
+ FaultPin::FaultPin(Pin& pin) : EventPin(&faultPinEvent, "Fault", &pin) {}
+}

FluidNC/src/Machine/FaultPin.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "EventPin.h"
+
+namespace Machine {
+ class FaultPin : public EventPin {
+ public:
+ FaultPin(Pin& pin);
+ };
+}

FluidNC/src/ProcessSettings.cpp

@@ -409,7 +409,7 @@ static Error show_limits(const char* value, WebUI::AuthenticationLevel auth_leve
  log_to(out, "Send ! to exit");
  log_to(out, "Homing Axes : ", limit_set(Machine::Axes::homingMask));
  log_to(out, "Limit Axes : ", limit_set(Machine::Axes::limitMask));
- log_to(out, " PosLimitPins NegLimitPins Probe");
+ log_to(out, " PosLimitPins NegLimitPins Probe Fault");
 
  const TickType_t interval = 500;
  TickType_t limit = xTaskGetTickCount();
@@ -420,7 +420,8 @@ static Error show_limits(const char* value, WebUI::AuthenticationLevel auth_leve
  log_to(out,
  ": ",
  limit_set(Machine::Axes::posLimitMask)
- << " " << limit_set(Machine::Axes::negLimitMask) << (config->_probe->get_state() ? " P" : ""));
+ << " " << limit_set(Machine::Axes::negLimitMask) << (config->_probe->get_state() ? " P " : " ")
+ << ((config->_axes->_faultPin && config->_axes->_faultPin->get()) ? " F" : ""));
  limit = thisTime + interval;
  }
  vTaskDelay(1);
@@ -493,11 +494,6 @@ static Error doJog(const char* value, WebUI::AuthenticationLevel auth_level, Cha
  return gc_execute_line(jogLine);
 }
 
-static const char* alarmString(ExecAlarm alarmNumber) {
- auto it = AlarmNames.find(alarmNumber);
- return it == AlarmNames.end() ? NULL : it->second;
-}
-
 static Error listAlarms(const char* value, WebUI::AuthenticationLevel auth_level, Channel& out) {
  if (sys.state == State::ConfigAlarm) {
  log_to(out, "Configuration alarm is active. Check the boot messages for 'ERR'.");

FluidNC/src/Protocol.cpp

@@ -18,6 +18,7 @@
 #include "MotionControl.h" // PARKING_MOTION_LINE_NUMBER
 #include "Settings.h" // settings_execute_startup
 #include "Machine/LimitPin.h"
+#include "Machine/FaultPin.h"
 
 volatile ExecAlarm rtAlarm; // Global realtime executor bitflag variable for setting various alarms.
 
@@ -35,8 +36,14 @@ std::map<ExecAlarm, const char*> AlarmNames = {
  { ExecAlarm::SpindleControl, "Spindle Control" },
  { ExecAlarm::ControlPin, "Control Pin Initially On" },
  { ExecAlarm::HomingAmbiguousSwitch, "Ambiguous Switch" },
+ { ExecAlarm::FaultPin, "Fault Pin" },
 };
 
+const char* alarmString(ExecAlarm alarmNumber) {
+ auto it = AlarmNames.find(alarmNumber);
+ return it == AlarmNames.end() ? NULL : it->second;
+}
+
 volatile bool rtReset;
 
 static volatile bool rtSafetyDoor;
@@ -361,6 +368,7 @@ void protocol_execute_realtime() {
 }
 
 static void alarm_msg(ExecAlarm alarm_code) {
+ log_info_to(allChannels, "ALARM: " << alarmString(alarm_code));
  log_to(allChannels, "ALARM:", static_cast<int>(alarm_code));
  delay_ms(500); // Force delay to ensure message clears serial write buffer.
 }
@@ -377,7 +385,7 @@ static void protocol_do_alarm() {
  }
  sys.state = State::Alarm; // Set system alarm state
  alarm_msg(rtAlarm);
- if (rtAlarm == ExecAlarm::HardLimit || rtAlarm == ExecAlarm::SoftLimit) {
+ if (rtAlarm == ExecAlarm::HardLimit || rtAlarm == ExecAlarm::SoftLimit || rtAlarm == ExecAlarm::FaultPin) {
  report_error_message(Message::CriticalEvent);
  protocol_disable_steppers();
  rtReset = false; // Disable any existing reset
@@ -705,6 +713,7 @@ void protocol_do_cycle_stop() {
  // Fall through
  case State::ConfigAlarm:
  case State::Alarm:
+ break;
  case State::CheckMode:
  case State::Idle:
  case State::Cycle:
@@ -1012,14 +1021,23 @@ static void protocol_do_limit(void* arg) {
  mc_reset(); // Initiate system kill.
  rtAlarm = ExecAlarm::HardLimit; // Indicate hard limit critical event
  }
- return;
+ }
+}
+static void protocol_do_fault_pin(void* arg) {
+ Machine::FaultPin* faultPin = (Machine::FaultPin*)arg;
+ if (sys.state == State::Cycle || sys.state == State::Jog) {
+ if (rtAlarm == ExecAlarm::None) {
+ mc_reset(); // Initiate system kill.
+ rtAlarm = ExecAlarm::FaultPin; // Indicate fault pin critical event
+ }
  }
 }
 ArgEvent feedOverrideEvent { protocol_do_feed_override };
 ArgEvent rapidOverrideEvent { protocol_do_rapid_override };
 ArgEvent spindleOverrideEvent { protocol_do_spindle_override };
 ArgEvent accessoryOverrideEvent { protocol_do_accessory_override };
 ArgEvent limitEvent { protocol_do_limit };
+ArgEvent faultPinEvent { protocol_do_fault_pin };
 
 ArgEvent reportStatusEvent { (void (*)(void*))report_realtime_status };
 

FluidNC/src/Protocol.h

@@ -64,13 +64,16 @@ enum class ExecAlarm : uint8_t {
  SpindleControl = 10,
  ControlPin = 11,
  HomingAmbiguousSwitch = 12,
+ FaultPin = 13,
 };
 
 extern volatile ExecAlarm rtAlarm; // Global realtime executor variable for setting various alarms.
 
 #include <map>
 extern std::map<ExecAlarm, const char*> AlarmNames;
 
+const char* alarmString(ExecAlarm alarmNumber);
+
 #include "Event.h"
 enum AccessoryOverride {
  SpindleStopOvr = 1,
@@ -83,6 +86,7 @@ extern ArgEvent rapidOverrideEvent;
 extern ArgEvent spindleOverrideEvent;
 extern ArgEvent accessoryOverrideEvent;
 extern ArgEvent limitEvent;
+extern ArgEvent faultPinEvent;
 
 extern ArgEvent reportStatusEvent;
 

FluidNC/src/Report.cpp

@@ -646,8 +646,7 @@ void report_realtime_status(Channel& channel) {
  msg << "|Heap:" << esp.getHeapSize();
 #endif
  msg << ">";
- // The DebugStream destructor sends the line
- // when msg goes out of scope
+ // The destructor sends the line when msg goes out of scope
 }
 
 void hex_msg(uint8_t* buf, const char* prefix, int len) {