337 lines
11 KiB
C++
337 lines
11 KiB
C++
/**
|
|
* Marlin 3D Printer Firmware
|
|
* Copyright (C) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|
*
|
|
* Based on Sprinter and grbl.
|
|
* Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "../../inc/MarlinConfig.h"
|
|
|
|
#if ENABLED(PINS_DEBUGGING)
|
|
|
|
#include "../gcode.h"
|
|
#include "../../Marlin.h" // for pin_is_protected
|
|
#include "../../pins/pinsDebug.h"
|
|
#include "../../module/endstops.h"
|
|
|
|
#if HAS_Z_SERVO_PROBE
|
|
#include "../../module/probe.h"
|
|
#include "../../module/servo.h"
|
|
#endif
|
|
|
|
#if ENABLED(HOST_PROMPT_SUPPORT)
|
|
#include "../../feature/host_actions.h"
|
|
#endif
|
|
|
|
inline void toggle_pins() {
|
|
const bool ignore_protection = parser.boolval('I');
|
|
const int repeat = parser.intval('R', 1),
|
|
start = PARSED_PIN_INDEX('S', 0),
|
|
end = PARSED_PIN_INDEX('L', NUM_DIGITAL_PINS - 1),
|
|
wait = parser.intval('W', 500);
|
|
|
|
for (uint8_t i = start; i <= end; i++) {
|
|
pin_t pin = GET_PIN_MAP_PIN(i);
|
|
if (!VALID_PIN(pin)) continue;
|
|
if (M43_NEVER_TOUCH(i) || (!ignore_protection && pin_is_protected(pin))) {
|
|
report_pin_state_extended(pin, ignore_protection, true, "Untouched ");
|
|
SERIAL_EOL();
|
|
}
|
|
else {
|
|
watchdog_reset();
|
|
report_pin_state_extended(pin, ignore_protection, true, "Pulsing ");
|
|
#if AVR_AT90USB1286_FAMILY // Teensy IDEs don't know about these pins so must use FASTIO
|
|
if (pin == TEENSY_E2) {
|
|
SET_OUTPUT(TEENSY_E2);
|
|
for (int16_t j = 0; j < repeat; j++) {
|
|
WRITE(TEENSY_E2, LOW); safe_delay(wait);
|
|
WRITE(TEENSY_E2, HIGH); safe_delay(wait);
|
|
WRITE(TEENSY_E2, LOW); safe_delay(wait);
|
|
}
|
|
}
|
|
else if (pin == TEENSY_E3) {
|
|
SET_OUTPUT(TEENSY_E3);
|
|
for (int16_t j = 0; j < repeat; j++) {
|
|
WRITE(TEENSY_E3, LOW); safe_delay(wait);
|
|
WRITE(TEENSY_E3, HIGH); safe_delay(wait);
|
|
WRITE(TEENSY_E3, LOW); safe_delay(wait);
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
pinMode(pin, OUTPUT);
|
|
for (int16_t j = 0; j < repeat; j++) {
|
|
watchdog_reset(); extDigitalWrite(pin, 0); safe_delay(wait);
|
|
watchdog_reset(); extDigitalWrite(pin, 1); safe_delay(wait);
|
|
watchdog_reset(); extDigitalWrite(pin, 0); safe_delay(wait);
|
|
watchdog_reset();
|
|
}
|
|
}
|
|
}
|
|
SERIAL_EOL();
|
|
}
|
|
SERIAL_ECHOLNPGM("Done.");
|
|
|
|
} // toggle_pins
|
|
|
|
inline void servo_probe_test() {
|
|
#if !(NUM_SERVOS > 0 && HAS_SERVO_0)
|
|
|
|
SERIAL_ERROR_MSG("SERVO not setup");
|
|
|
|
#elif !HAS_Z_SERVO_PROBE
|
|
|
|
SERIAL_ERROR_MSG("Z_PROBE_SERVO_NR not setup");
|
|
|
|
#else // HAS_Z_SERVO_PROBE
|
|
|
|
const uint8_t probe_index = parser.byteval('P', Z_PROBE_SERVO_NR);
|
|
|
|
SERIAL_ECHOLNPGM("Servo probe test");
|
|
SERIAL_ECHOLNPAIR(". using index: ", probe_index);
|
|
SERIAL_ECHOLNPAIR(". deploy angle: ", servo_angles[probe_index][0]);
|
|
SERIAL_ECHOLNPAIR(". stow angle: ", servo_angles[probe_index][1]);
|
|
|
|
bool probe_inverting;
|
|
|
|
#if ENABLED(Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN)
|
|
|
|
#define PROBE_TEST_PIN Z_MIN_PIN
|
|
|
|
SERIAL_ECHOLNPAIR(". probe uses Z_MIN pin: ", PROBE_TEST_PIN);
|
|
SERIAL_ECHOLNPGM(". uses Z_MIN_ENDSTOP_INVERTING (ignores Z_MIN_PROBE_ENDSTOP_INVERTING)");
|
|
SERIAL_ECHOPGM(". Z_MIN_ENDSTOP_INVERTING: ");
|
|
|
|
#if Z_MIN_ENDSTOP_INVERTING
|
|
SERIAL_ECHOLNPGM("true");
|
|
#else
|
|
SERIAL_ECHOLNPGM("false");
|
|
#endif
|
|
|
|
probe_inverting = Z_MIN_ENDSTOP_INVERTING;
|
|
|
|
#elif USES_Z_MIN_PROBE_ENDSTOP
|
|
|
|
#define PROBE_TEST_PIN Z_MIN_PROBE_PIN
|
|
SERIAL_ECHOLNPAIR(". probe uses Z_MIN_PROBE_PIN: ", PROBE_TEST_PIN);
|
|
SERIAL_ECHOLNPGM(". uses Z_MIN_PROBE_ENDSTOP_INVERTING (ignores Z_MIN_ENDSTOP_INVERTING)");
|
|
SERIAL_ECHOPGM(". Z_MIN_PROBE_ENDSTOP_INVERTING: ");
|
|
|
|
#if Z_MIN_PROBE_ENDSTOP_INVERTING
|
|
SERIAL_ECHOLNPGM("true");
|
|
#else
|
|
SERIAL_ECHOLNPGM("false");
|
|
#endif
|
|
|
|
probe_inverting = Z_MIN_PROBE_ENDSTOP_INVERTING;
|
|
|
|
#endif
|
|
|
|
SERIAL_ECHOLNPGM(". deploy & stow 4 times");
|
|
SET_INPUT_PULLUP(PROBE_TEST_PIN);
|
|
uint8_t i = 0;
|
|
bool deploy_state, stow_state;
|
|
do {
|
|
MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
|
|
safe_delay(500);
|
|
deploy_state = READ(PROBE_TEST_PIN);
|
|
MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
|
|
safe_delay(500);
|
|
stow_state = READ(PROBE_TEST_PIN);
|
|
} while (++i < 4);
|
|
if (probe_inverting != deploy_state) SERIAL_ECHOLNPGM("WARNING - INVERTING setting probably backwards");
|
|
|
|
if (deploy_state != stow_state) {
|
|
SERIAL_ECHOLNPGM("BLTouch clone detected");
|
|
if (deploy_state) {
|
|
SERIAL_ECHOLNPGM(". DEPLOYED state: HIGH (logic 1)");
|
|
SERIAL_ECHOLNPGM(". STOWED (triggered) state: LOW (logic 0)");
|
|
}
|
|
else {
|
|
SERIAL_ECHOLNPGM(". DEPLOYED state: LOW (logic 0)");
|
|
SERIAL_ECHOLNPGM(". STOWED (triggered) state: HIGH (logic 1)");
|
|
}
|
|
#if ENABLED(BLTOUCH)
|
|
SERIAL_ECHOLNPGM("ERROR: BLTOUCH enabled - set this device up as a Z Servo Probe with inverting as true.");
|
|
#endif
|
|
}
|
|
else { // measure active signal length
|
|
MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
|
|
safe_delay(500);
|
|
SERIAL_ECHOLNPGM("please trigger probe");
|
|
uint16_t probe_counter = 0;
|
|
|
|
// Allow 30 seconds max for operator to trigger probe
|
|
for (uint16_t j = 0; j < 500 * 30 && probe_counter == 0 ; j++) {
|
|
|
|
safe_delay(2);
|
|
|
|
if (0 == j % (500 * 1)) gcode.reset_stepper_timeout(); // Keep steppers powered
|
|
|
|
if (deploy_state != READ(PROBE_TEST_PIN)) { // probe triggered
|
|
|
|
for (probe_counter = 1; probe_counter < 50 && deploy_state != READ(PROBE_TEST_PIN); ++probe_counter)
|
|
safe_delay(2);
|
|
|
|
if (probe_counter == 50)
|
|
SERIAL_ECHOLNPGM("Z Servo Probe detected"); // >= 100mS active time
|
|
else if (probe_counter >= 2)
|
|
SERIAL_ECHOLNPAIR("BLTouch compatible probe detected - pulse width (+/- 4mS): ", probe_counter * 2); // allow 4 - 100mS pulse
|
|
else
|
|
SERIAL_ECHOLNPGM("noise detected - please re-run test"); // less than 2mS pulse
|
|
|
|
MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
|
|
|
|
} // pulse detected
|
|
|
|
} // for loop waiting for trigger
|
|
|
|
if (probe_counter == 0) SERIAL_ECHOLNPGM("trigger not detected");
|
|
|
|
} // measure active signal length
|
|
|
|
#endif
|
|
|
|
} // servo_probe_test
|
|
|
|
/**
|
|
* M43: Pin debug - report pin state, watch pins, toggle pins and servo probe test/report
|
|
*
|
|
* M43 - report name and state of pin(s)
|
|
* P<pin> Pin to read or watch. If omitted, reads all pins.
|
|
* I Flag to ignore Marlin's pin protection.
|
|
*
|
|
* M43 W - Watch pins -reporting changes- until reset, click, or M108.
|
|
* P<pin> Pin to read or watch. If omitted, read/watch all pins.
|
|
* I Flag to ignore Marlin's pin protection.
|
|
*
|
|
* M43 E<bool> - Enable / disable background endstop monitoring
|
|
* - Machine continues to operate
|
|
* - Reports changes to endstops
|
|
* - Toggles LED_PIN when an endstop changes
|
|
* - Cannot reliably catch the 5mS pulse from BLTouch type probes
|
|
*
|
|
* M43 T - Toggle pin(s) and report which pin is being toggled
|
|
* S<pin> - Start Pin number. If not given, will default to 0
|
|
* L<pin> - End Pin number. If not given, will default to last pin defined for this board
|
|
* I<bool> - Flag to ignore Marlin's pin protection. Use with caution!!!!
|
|
* R - Repeat pulses on each pin this number of times before continueing to next pin
|
|
* W - Wait time (in miliseconds) between pulses. If not given will default to 500
|
|
*
|
|
* M43 S - Servo probe test
|
|
* P<index> - Probe index (optional - defaults to 0
|
|
*/
|
|
void GcodeSuite::M43() {
|
|
|
|
if (parser.seen('T')) { // must be first or else its "S" and "E" parameters will execute endstop or servo test
|
|
toggle_pins();
|
|
return;
|
|
}
|
|
|
|
// Enable or disable endstop monitoring
|
|
if (parser.seen('E')) {
|
|
endstops.monitor_flag = parser.value_bool();
|
|
SERIAL_ECHOPGM("endstop monitor ");
|
|
serialprintPGM(endstops.monitor_flag ? PSTR("en") : PSTR("dis"));
|
|
SERIAL_ECHOLNPGM("abled");
|
|
return;
|
|
}
|
|
|
|
if (parser.seen('S')) {
|
|
servo_probe_test();
|
|
return;
|
|
}
|
|
|
|
// Get the range of pins to test or watch
|
|
uint8_t first_pin = PARSED_PIN_INDEX('P', 0),
|
|
last_pin = parser.seenval('P') ? first_pin : NUMBER_PINS_TOTAL - 1;
|
|
|
|
if (first_pin > last_pin) return;
|
|
|
|
const bool ignore_protection = parser.boolval('I');
|
|
|
|
// Watch until click, M108, or reset
|
|
if (parser.boolval('W')) {
|
|
SERIAL_ECHOLNPGM("Watching pins");
|
|
|
|
#ifdef ARDUINO_ARCH_SAM
|
|
NOLESS(first_pin, 2); // don't hijack the UART pins
|
|
#endif
|
|
uint8_t pin_state[last_pin - first_pin + 1];
|
|
for (uint8_t i = first_pin; i <= last_pin; i++) {
|
|
pin_t pin = GET_PIN_MAP_PIN(i);
|
|
if (!VALID_PIN(pin)) continue;
|
|
if (M43_NEVER_TOUCH(i) || (!ignore_protection && pin_is_protected(pin))) continue;
|
|
pinMode(pin, INPUT_PULLUP);
|
|
delay(1);
|
|
/*
|
|
if (IS_ANALOG(pin))
|
|
pin_state[pin - first_pin] = analogRead(DIGITAL_PIN_TO_ANALOG_PIN(pin)); // int16_t pin_state[...]
|
|
else
|
|
//*/
|
|
pin_state[i - first_pin] = extDigitalRead(pin);
|
|
}
|
|
|
|
#if HAS_RESUME_CONTINUE
|
|
wait_for_user = true;
|
|
#if ENABLED(HOST_PROMPT_SUPPORT)
|
|
host_prompt_do(PROMPT_USER_CONTINUE, PSTR("M43 Wait Called"), PSTR("Continue"));
|
|
#endif
|
|
KEEPALIVE_STATE(PAUSED_FOR_USER);
|
|
#endif
|
|
|
|
for (;;) {
|
|
for (uint8_t i = first_pin; i <= last_pin; i++) {
|
|
pin_t pin = GET_PIN_MAP_PIN(i);
|
|
if (!VALID_PIN(pin)) continue;
|
|
if (M43_NEVER_TOUCH(i) || (!ignore_protection && pin_is_protected(pin))) continue;
|
|
const byte val =
|
|
/*
|
|
IS_ANALOG(pin)
|
|
? analogRead(DIGITAL_PIN_TO_ANALOG_PIN(pin)) : // int16_t val
|
|
:
|
|
//*/
|
|
extDigitalRead(pin);
|
|
if (val != pin_state[i - first_pin]) {
|
|
report_pin_state_extended(pin, ignore_protection, false);
|
|
pin_state[i - first_pin] = val;
|
|
}
|
|
}
|
|
|
|
#if HAS_RESUME_CONTINUE
|
|
if (!wait_for_user) {
|
|
KEEPALIVE_STATE(IN_HANDLER);
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
safe_delay(200);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Report current state of selected pin(s)
|
|
for (uint8_t i = first_pin; i <= last_pin; i++) {
|
|
pin_t pin = GET_PIN_MAP_PIN(i);
|
|
if (VALID_PIN(pin)) report_pin_state_extended(pin, ignore_protection, true);
|
|
}
|
|
}
|
|
|
|
#endif // PINS_DEBUGGING
|