From e8701195e66f2d27ffe17fb514eae8173795aaf7 Mon Sep 17 00:00:00 2001 From: Georgiy Bondarenko <69736697+nehilo@users.noreply.github.com> Date: Thu, 4 Mar 2021 22:54:23 +0500 Subject: Initial commit --- Marlin/src/gcode/host/M110.cpp | 34 +++++++ Marlin/src/gcode/host/M113.cpp | 45 +++++++++ Marlin/src/gcode/host/M114.cpp | 214 +++++++++++++++++++++++++++++++++++++++++ Marlin/src/gcode/host/M115.cpp | 171 ++++++++++++++++++++++++++++++++ Marlin/src/gcode/host/M118.cpp | 66 +++++++++++++ Marlin/src/gcode/host/M119.cpp | 33 +++++++ Marlin/src/gcode/host/M16.cpp | 40 ++++++++ Marlin/src/gcode/host/M360.cpp | 186 +++++++++++++++++++++++++++++++++++ Marlin/src/gcode/host/M876.cpp | 39 ++++++++ 9 files changed, 828 insertions(+) create mode 100644 Marlin/src/gcode/host/M110.cpp create mode 100644 Marlin/src/gcode/host/M113.cpp create mode 100644 Marlin/src/gcode/host/M114.cpp create mode 100644 Marlin/src/gcode/host/M115.cpp create mode 100644 Marlin/src/gcode/host/M118.cpp create mode 100644 Marlin/src/gcode/host/M119.cpp create mode 100644 Marlin/src/gcode/host/M16.cpp create mode 100644 Marlin/src/gcode/host/M360.cpp create mode 100644 Marlin/src/gcode/host/M876.cpp (limited to 'Marlin/src/gcode/host') diff --git a/Marlin/src/gcode/host/M110.cpp b/Marlin/src/gcode/host/M110.cpp new file mode 100644 index 0000000..b12b38e --- /dev/null +++ b/Marlin/src/gcode/host/M110.cpp @@ -0,0 +1,34 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 . + * + */ + +#include "../gcode.h" +#include "../queue.h" // for last_N + +/** + * M110: Set Current Line Number + */ +void GcodeSuite::M110() { + + if (parser.seenval('N')) + queue.last_N[queue.command_port()] = parser.value_long(); + +} diff --git a/Marlin/src/gcode/host/M113.cpp b/Marlin/src/gcode/host/M113.cpp new file mode 100644 index 0000000..ce826d6 --- /dev/null +++ b/Marlin/src/gcode/host/M113.cpp @@ -0,0 +1,45 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 . + * + */ + +#include "../../inc/MarlinConfig.h" + +#if ENABLED(HOST_KEEPALIVE_FEATURE) + +#include "../gcode.h" + +/** + * M113: Get or set Host Keepalive interval (0 to disable) + * + * S Optional. Set the keepalive interval. + */ +void GcodeSuite::M113() { + if (parser.seenval('S')) { + host_keepalive_interval = parser.value_byte(); + NOMORE(host_keepalive_interval, 60); + } + else { + SERIAL_ECHO_START(); + SERIAL_ECHOLNPAIR("M113 S", (unsigned long)host_keepalive_interval); + } +} + +#endif // HOST_KEEPALIVE_FEATURE diff --git a/Marlin/src/gcode/host/M114.cpp b/Marlin/src/gcode/host/M114.cpp new file mode 100644 index 0000000..75356ff --- /dev/null +++ b/Marlin/src/gcode/host/M114.cpp @@ -0,0 +1,214 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 . + * + */ + +#include "../../inc/MarlinConfig.h" + +#include "../gcode.h" +#include "../../module/motion.h" +#include "../../module/stepper.h" + +#if ENABLED(M114_DETAIL) + + #if HAS_L64XX + #include "../../libs/L64XX/L64XX_Marlin.h" + #define DEBUG_OUT ENABLED(L6470_CHITCHAT) + #include "../../core/debug_out.h" + #endif + + void report_xyze(const xyze_pos_t &pos, const uint8_t n=XYZE, const uint8_t precision=3) { + char str[12]; + LOOP_L_N(a, n) { + SERIAL_CHAR(' ', axis_codes[a], ':'); + if (pos[a] >= 0) SERIAL_CHAR(' '); + SERIAL_ECHO(dtostrf(pos[a], 1, precision, str)); + } + SERIAL_EOL(); + } + inline void report_xyz(const xyze_pos_t &pos) { report_xyze(pos, XYZ); } + + void report_xyz(const xyz_pos_t &pos, const uint8_t precision=3) { + char str[12]; + LOOP_XYZ(a) { + SERIAL_CHAR(' ', XYZ_CHAR(a), ':'); + SERIAL_ECHO(dtostrf(pos[a], 1, precision, str)); + } + SERIAL_EOL(); + } + + void report_current_position_detail() { + // Position as sent by G-code + SERIAL_ECHOPGM("\nLogical:"); + report_xyz(current_position.asLogical()); + + // Cartesian position in native machine space + SERIAL_ECHOPGM("Raw: "); + report_xyz(current_position); + + xyze_pos_t leveled = current_position; + + #if HAS_LEVELING + // Current position with leveling applied + SERIAL_ECHOPGM("Leveled:"); + planner.apply_leveling(leveled); + report_xyz(leveled); + + // Test planner un-leveling. This should match the Raw result. + SERIAL_ECHOPGM("UnLevel:"); + xyze_pos_t unleveled = leveled; + planner.unapply_leveling(unleveled); + report_xyz(unleveled); + #endif + + #if IS_KINEMATIC + // Kinematics applied to the leveled position + SERIAL_ECHOPGM(TERN(IS_SCARA, "ScaraK: ", "DeltaK: ")); + inverse_kinematics(leveled); // writes delta[] + report_xyz(delta); + #endif + + planner.synchronize(); + + #if HAS_L64XX + char temp_buf[80]; + int32_t temp; + //#define ABS_POS_SIGN_MASK 0b1111 1111 1110 0000 0000 0000 0000 0000 + #define ABS_POS_SIGN_MASK 0b11111111111000000000000000000000 + #define REPORT_ABSOLUTE_POS(Q) do{ \ + L64xxManager.say_axis(Q, false); \ + temp = L6470_GETPARAM(L6470_ABS_POS,Q); \ + if (temp & ABS_POS_SIGN_MASK) temp |= ABS_POS_SIGN_MASK; \ + sprintf_P(temp_buf, PSTR(":%8ld "), temp); \ + DEBUG_ECHO(temp_buf); \ + }while(0) + + DEBUG_ECHOPGM("\nL6470:"); + #if AXIS_IS_L64XX(X) + REPORT_ABSOLUTE_POS(X); + #endif + #if AXIS_IS_L64XX(X2) + REPORT_ABSOLUTE_POS(X2); + #endif + #if AXIS_IS_L64XX(Y) + REPORT_ABSOLUTE_POS(Y); + #endif + #if AXIS_IS_L64XX(Y2) + REPORT_ABSOLUTE_POS(Y2); + #endif + #if AXIS_IS_L64XX(Z) + REPORT_ABSOLUTE_POS(Z); + #endif + #if AXIS_IS_L64XX(Z2) + REPORT_ABSOLUTE_POS(Z2); + #endif + #if AXIS_IS_L64XX(Z3) + REPORT_ABSOLUTE_POS(Z3); + #endif + #if AXIS_IS_L64XX(Z4) + REPORT_ABSOLUTE_POS(Z4); + #endif + #if AXIS_IS_L64XX(E0) + REPORT_ABSOLUTE_POS(E0); + #endif + #if AXIS_IS_L64XX(E1) + REPORT_ABSOLUTE_POS(E1); + #endif + #if AXIS_IS_L64XX(E2) + REPORT_ABSOLUTE_POS(E2); + #endif + #if AXIS_IS_L64XX(E3) + REPORT_ABSOLUTE_POS(E3); + #endif + #if AXIS_IS_L64XX(E4) + REPORT_ABSOLUTE_POS(E4); + #endif + #if AXIS_IS_L64XX(E5) + REPORT_ABSOLUTE_POS(E5); + #endif + #if AXIS_IS_L64XX(E6) + REPORT_ABSOLUTE_POS(E6); + #endif + #if AXIS_IS_L64XX(E7) + REPORT_ABSOLUTE_POS(E7); + #endif + SERIAL_EOL(); + #endif // HAS_L64XX + + SERIAL_ECHOPGM("Stepper:"); + LOOP_XYZE(i) { + SERIAL_CHAR(' ', axis_codes[i], ':'); + SERIAL_ECHO(stepper.position((AxisEnum)i)); + } + SERIAL_EOL(); + + #if IS_SCARA + const xy_float_t deg = { + planner.get_axis_position_degrees(A_AXIS), + planner.get_axis_position_degrees(B_AXIS) + }; + SERIAL_ECHOPGM("Degrees:"); + report_xyze(deg, 2); + #endif + + SERIAL_ECHOPGM("FromStp:"); + get_cartesian_from_steppers(); // writes 'cartes' (with forward kinematics) + xyze_pos_t from_steppers = { cartes.x, cartes.y, cartes.z, planner.get_axis_position_mm(E_AXIS) }; + report_xyze(from_steppers); + + const xyze_float_t diff = from_steppers - leveled; + SERIAL_ECHOPGM("Diff: "); + report_xyze(diff); + } + +#endif // M114_DETAIL + +/** + * M114: Report the current position to host. + * Since steppers are moving, the count positions are + * projected by using planner calculations. + * D - Report more detail. This syncs the planner. (Requires M114_DETAIL) + * E - Report E stepper position (Requires M114_DETAIL) + * R - Report the realtime position instead of projected. + */ +void GcodeSuite::M114() { + + #if ENABLED(M114_DETAIL) + if (parser.seen('D')) { + #if DISABLED(M114_LEGACY) + planner.synchronize(); + #endif + report_current_position(); + report_current_position_detail(); + return; + } + if (parser.seen('E')) { + SERIAL_ECHOLNPAIR("Count E:", stepper.position(E_AXIS)); + return; + } + #endif + + #if ENABLED(M114_REALTIME) + if (parser.seen('R')) { report_real_position(); return; } + #endif + + TERN_(M114_LEGACY, planner.synchronize()); + report_current_position_projected(); +} diff --git a/Marlin/src/gcode/host/M115.cpp b/Marlin/src/gcode/host/M115.cpp new file mode 100644 index 0000000..0501f3f --- /dev/null +++ b/Marlin/src/gcode/host/M115.cpp @@ -0,0 +1,171 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 . + * + */ + +#include "../gcode.h" +#include "../../inc/MarlinConfig.h" + +#if ENABLED(M115_GEOMETRY_REPORT) + #include "../../module/motion.h" +#endif + +#if ENABLED(CASE_LIGHT_ENABLE) + #include "../../feature/caselight.h" +#endif + +#if ENABLED(EXTENDED_CAPABILITIES_REPORT) + static void cap_line(PGM_P const name, bool ena=false) { + SERIAL_ECHOPGM("Cap:"); + serialprintPGM(name); + SERIAL_CHAR(':', ena ? '1' : '0'); + SERIAL_EOL(); + } +#endif + +/** + * M115: Capabilities string and extended capabilities report + * If a capability is not reported, hosts should assume + * the capability is not present. + */ +void GcodeSuite::M115() { + SERIAL_ECHOLNPGM( + "FIRMWARE_NAME:Marlin " DETAILED_BUILD_VERSION " (" __DATE__ " " __TIME__ ") " + "SOURCE_CODE_URL:" SOURCE_CODE_URL " " + "PROTOCOL_VERSION:" PROTOCOL_VERSION " " + "MACHINE_TYPE:" MACHINE_NAME " " + "EXTRUDER_COUNT:" STRINGIFY(EXTRUDERS) " " + #ifdef MACHINE_UUID + "UUID:" MACHINE_UUID + #endif + ); + + #if ENABLED(EXTENDED_CAPABILITIES_REPORT) + + // PAREN_COMMENTS + TERN_(PAREN_COMMENTS, cap_line(PSTR("PAREN_COMMENTS"), true)); + + // QUOTED_STRINGS + TERN_(GCODE_QUOTED_STRINGS, cap_line(PSTR("QUOTED_STRINGS"), true)); + + // SERIAL_XON_XOFF + cap_line(PSTR("SERIAL_XON_XOFF"), ENABLED(SERIAL_XON_XOFF)); + + // BINARY_FILE_TRANSFER (M28 B1) + cap_line(PSTR("BINARY_FILE_TRANSFER"), ENABLED(BINARY_FILE_TRANSFER)); + + // EEPROM (M500, M501) + cap_line(PSTR("EEPROM"), ENABLED(EEPROM_SETTINGS)); + + // Volumetric Extrusion (M200) + cap_line(PSTR("VOLUMETRIC"), DISABLED(NO_VOLUMETRICS)); + + // AUTOREPORT_TEMP (M155) + cap_line(PSTR("AUTOREPORT_TEMP"), ENABLED(AUTO_REPORT_TEMPERATURES)); + + // PROGRESS (M530 S L, M531 , M532 X L) + cap_line(PSTR("PROGRESS")); + + // Print Job timer M75, M76, M77 + cap_line(PSTR("PRINT_JOB"), true); + + // AUTOLEVEL (G29) + cap_line(PSTR("AUTOLEVEL"), ENABLED(HAS_AUTOLEVEL)); + + // RUNOUT (M412, M600) + cap_line(PSTR("RUNOUT"), ENABLED(FILAMENT_RUNOUT_SENSOR)); + + // Z_PROBE (G30) + cap_line(PSTR("Z_PROBE"), ENABLED(HAS_BED_PROBE)); + + // MESH_REPORT (M420 V) + cap_line(PSTR("LEVELING_DATA"), ENABLED(HAS_LEVELING)); + + // BUILD_PERCENT (M73) + cap_line(PSTR("BUILD_PERCENT"), ENABLED(LCD_SET_PROGRESS_MANUALLY)); + + // SOFTWARE_POWER (M80, M81) + cap_line(PSTR("SOFTWARE_POWER"), ENABLED(PSU_CONTROL)); + + // TOGGLE_LIGHTS (M355) + cap_line(PSTR("TOGGLE_LIGHTS"), ENABLED(CASE_LIGHT_ENABLE)); + cap_line(PSTR("CASE_LIGHT_BRIGHTNESS"), TERN0(CASE_LIGHT_ENABLE, TERN0(CASELIGHT_USES_BRIGHTNESS, TERN(CASE_LIGHT_USE_NEOPIXEL, true, PWM_PIN(CASE_LIGHT_PIN))))); + + // EMERGENCY_PARSER (M108, M112, M410, M876) + cap_line(PSTR("EMERGENCY_PARSER"), ENABLED(EMERGENCY_PARSER)); + + // PROMPT SUPPORT (M876) + cap_line(PSTR("PROMPT_SUPPORT"), ENABLED(HOST_PROMPT_SUPPORT)); + + // SDCARD (M20, M23, M24, etc.) + cap_line(PSTR("SDCARD"), ENABLED(SDSUPPORT)); + + // REPEAT (M808) + cap_line(PSTR("REPEAT"), ENABLED(GCODE_REPEAT_MARKERS)); + + // AUTOREPORT_SD_STATUS (M27 extension) + cap_line(PSTR("AUTOREPORT_SD_STATUS"), ENABLED(AUTO_REPORT_SD_STATUS)); + + // LONG_FILENAME_HOST_SUPPORT (M33) + cap_line(PSTR("LONG_FILENAME"), ENABLED(LONG_FILENAME_HOST_SUPPORT)); + + // THERMAL_PROTECTION + cap_line(PSTR("THERMAL_PROTECTION"), ENABLED(THERMALLY_SAFE)); + + // MOTION_MODES (M80-M89) + cap_line(PSTR("MOTION_MODES"), ENABLED(GCODE_MOTION_MODES)); + + // ARC_SUPPORT (G2-G3) + cap_line(PSTR("ARCS"), ENABLED(ARC_SUPPORT)); + + // BABYSTEPPING (M290) + cap_line(PSTR("BABYSTEPPING"), ENABLED(BABYSTEPPING)); + + // CHAMBER_TEMPERATURE (M141, M191) + cap_line(PSTR("CHAMBER_TEMPERATURE"), ENABLED(HAS_HEATED_CHAMBER)); + + // MEATPACK Compresson + cap_line(PSTR("MEATPACK"), ENABLED(MEATPACK)); + + // Machine Geometry + #if ENABLED(M115_GEOMETRY_REPORT) + const xyz_pos_t dmin = { X_MIN_POS, Y_MIN_POS, Z_MIN_POS }, + dmax = { X_MAX_POS, Y_MAX_POS, Z_MAX_POS }; + xyz_pos_t cmin = dmin, cmax = dmax; + apply_motion_limits(cmin); + apply_motion_limits(cmax); + const xyz_pos_t lmin = dmin.asLogical(), lmax = dmax.asLogical(), + wmin = cmin.asLogical(), wmax = cmax.asLogical(); + SERIAL_ECHOLNPAIR( + "area:{" + "full:{" + "min:{x:", lmin.x, ",y:", lmin.y, ",z:", lmin.z, "}," + "max:{x:", lmax.x, ",y:", lmax.y, ",z:", lmax.z, "}" + "}," + "work:{" + "min:{x:", wmin.x, ",y:", wmin.y, ",z:", wmin.z, "}," + "max:{x:", wmax.x, ",y:", wmax.y, ",z:", wmax.z, "}", + "}" + "}" + ); + #endif + + #endif // EXTENDED_CAPABILITIES_REPORT +} diff --git a/Marlin/src/gcode/host/M118.cpp b/Marlin/src/gcode/host/M118.cpp new file mode 100644 index 0000000..73115d5 --- /dev/null +++ b/Marlin/src/gcode/host/M118.cpp @@ -0,0 +1,66 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 . + * + */ + +#include "../gcode.h" +#include "../../core/serial.h" + +/** + * M118: Display a message in the host console. + * + * A1 Prepend '// ' for an action command, as in OctoPrint + * E1 Have the host 'echo:' the text + * Pn Redirect to another serial port + * 0 : Announce to all ports + * 1-9 : Serial ports 1 to 9 + */ +void GcodeSuite::M118() { + bool hasE = false, hasA = false; + #if HAS_MULTI_SERIAL + int8_t port = -1; // Assume no redirect + #endif + char *p = parser.string_arg; + for (uint8_t i = 3; i--;) { + // A1, E1, and Pn are always parsed out + if (!( ((p[0] == 'A' || p[0] == 'E') && p[1] == '1') || (p[0] == 'P' && NUMERIC(p[1])) )) break; + switch (p[0]) { + case 'A': hasA = true; break; + case 'E': hasE = true; break; + #if HAS_MULTI_SERIAL + case 'P': port = p[1] - '0'; break; + #endif + } + p += 2; + while (*p == ' ') ++p; + } + + #if HAS_MULTI_SERIAL + const int8_t old_serial = multiSerial.portMask; + if (WITHIN(port, 0, NUM_SERIAL)) + multiSerial.portMask = port ? _BV(port - 1) : SERIAL_ALL; + #endif + + if (hasE) SERIAL_ECHO_START(); + if (hasA) SERIAL_ECHOPGM("//"); + SERIAL_ECHOLN(p); + + TERN_(HAS_MULTI_SERIAL, multiSerial.portMask = old_serial); +} diff --git a/Marlin/src/gcode/host/M119.cpp b/Marlin/src/gcode/host/M119.cpp new file mode 100644 index 0000000..f0066bd --- /dev/null +++ b/Marlin/src/gcode/host/M119.cpp @@ -0,0 +1,33 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 . + * + */ + +#include "../gcode.h" +#include "../../module/endstops.h" + +/** + * M119: Output endstop states to serial output + */ +void GcodeSuite::M119() { + + endstops.report_states(); + +} diff --git a/Marlin/src/gcode/host/M16.cpp b/Marlin/src/gcode/host/M16.cpp new file mode 100644 index 0000000..1ac8580 --- /dev/null +++ b/Marlin/src/gcode/host/M16.cpp @@ -0,0 +1,40 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 . + * + */ + +#include "../../inc/MarlinConfigPre.h" + +#if ENABLED(EXPECTED_PRINTER_CHECK) + +#include "../gcode.h" +#include "../../MarlinCore.h" + +/** + * M16: Expected Printer Check + */ +void GcodeSuite::M16() { + + if (strcmp_P(parser.string_arg, PSTR(MACHINE_NAME))) + kill(GET_TEXT(MSG_KILL_EXPECTED_PRINTER)); + +} + +#endif diff --git a/Marlin/src/gcode/host/M360.cpp b/Marlin/src/gcode/host/M360.cpp new file mode 100644 index 0000000..f49a32c --- /dev/null +++ b/Marlin/src/gcode/host/M360.cpp @@ -0,0 +1,186 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 . + * + */ +#include "../../inc/MarlinConfig.h" + +#if ENABLED(REPETIER_GCODE_M360) + +#include "../gcode.h" + +#include "../../module/motion.h" +#include "../../module/planner.h" + +#if EXTRUDERS + #include "../../module/temperature.h" +#endif + +static void config_prefix(PGM_P const name, PGM_P const pref=nullptr, const int8_t ind=-1) { + SERIAL_ECHOPGM("Config:"); + if (pref) serialprintPGM(pref); + if (ind >= 0) { SERIAL_ECHO(int(ind)); SERIAL_CHAR(':'); } + serialprintPGM(name); + SERIAL_CHAR(':'); +} +static void config_line(PGM_P const name, const float val, PGM_P const pref=nullptr, const int8_t ind=-1) { + config_prefix(name, pref, ind); + SERIAL_ECHOLN(val); +} +static void config_line_e(const int8_t e, PGM_P const name, const float val) { + config_line(name, val, PSTR("Extr."), e + 1); +} + +/** + * M360: Report Firmware configuration + * in RepRapFirmware-compatible format + */ +void GcodeSuite::M360() { + PGMSTR(X_STR, "X"); + PGMSTR(Y_STR, "Y"); + PGMSTR(Z_STR, "Z"); + PGMSTR(JERK_STR, "Jerk"); + + // + // Basics and Enabled items + // + config_line(PSTR("Baudrate"), BAUDRATE); + config_line(PSTR("InputBuffer"), MAX_CMD_SIZE); + config_line(PSTR("PrintlineCache"), BUFSIZE); + config_line(PSTR("MixingExtruder"), ENABLED(MIXING_EXTRUDER)); + config_line(PSTR("SDCard"), ENABLED(SDSUPPORT)); + config_line(PSTR("Fan"), ENABLED(HAS_FAN)); + config_line(PSTR("LCD"), ENABLED(HAS_DISPLAY)); + config_line(PSTR("SoftwarePowerSwitch"), 1); + config_line(PSTR("SupportLocalFilamentchange"), ENABLED(ADVANCED_PAUSE_FEATURE)); + config_line(PSTR("CaseLights"), ENABLED(CASE_LIGHT_ENABLE)); + config_line(PSTR("ZProbe"), ENABLED(HAS_BED_PROBE)); + config_line(PSTR("Autolevel"), ENABLED(HAS_LEVELING)); + config_line(PSTR("EEPROM"), ENABLED(EEPROM_SETTINGS)); + + // + // Homing Directions + // + PGMSTR(H_DIR_STR, "HomeDir"); + config_line(H_DIR_STR, X_HOME_DIR, X_STR); + config_line(H_DIR_STR, Y_HOME_DIR, Y_STR); + config_line(H_DIR_STR, Z_HOME_DIR, Z_STR); + + // + // XYZ Axis Jerk + // + #if HAS_CLASSIC_JERK + if (planner.max_jerk.x == planner.max_jerk.y) + config_line(PSTR("XY"), planner.max_jerk.x, JERK_STR); + else { + config_line(X_STR, planner.max_jerk.x, JERK_STR); + config_line(Y_STR, planner.max_jerk.y, JERK_STR); + } + config_line(Z_STR, planner.max_jerk.z, JERK_STR); + #endif + + // + // Firmware Retraction + // + config_line(PSTR("SupportG10G11"), ENABLED(FWRETRACT)); + #if ENABLED(FWRETRACT) + PGMSTR(RET_STR, "Retraction"); + PGMSTR(UNRET_STR, "RetractionUndo"); + PGMSTR(SPEED_STR, "Speed"); + // M10 Retract with swap (long) moves + config_line(PSTR("Length"), fwretract.settings.retract_length, RET_STR); + config_line(SPEED_STR, fwretract.settings.retract_feedrate_mm_s, RET_STR); + config_line(PSTR("ZLift"), fwretract.settings.retract_zraise, RET_STR); + config_line(PSTR("LongLength"), fwretract.settings.swap_retract_length, RET_STR); + // M11 Recover (undo) with swap (long) moves + config_line(SPEED_STR, fwretract.settings.retract_recover_feedrate_mm_s, UNRET_STR); + config_line(PSTR("ExtraLength"), fwretract.settings.retract_recover_extra, UNRET_STR); + config_line(PSTR("ExtraLongLength"), fwretract.settings.swap_retract_recover_extra, UNRET_STR); + config_line(PSTR("LongSpeed"), fwretract.settings.swap_retract_recover_feedrate_mm_s, UNRET_STR); + #endif + + // + // Workspace boundaries + // + const xyz_pos_t dmin = { X_MIN_POS, Y_MIN_POS, Z_MIN_POS }, + dmax = { X_MAX_POS, Y_MAX_POS, Z_MAX_POS }; + xyz_pos_t cmin = dmin, cmax = dmax; + apply_motion_limits(cmin); + apply_motion_limits(cmax); + const xyz_pos_t wmin = cmin.asLogical(), wmax = cmax.asLogical(); + + PGMSTR(MIN_STR, "Min"); + PGMSTR(MAX_STR, "Max"); + PGMSTR(SIZE_STR, "Size"); + config_line(MIN_STR, wmin.x, X_STR); + config_line(MIN_STR, wmin.y, Y_STR); + config_line(MIN_STR, wmin.z, Z_STR); + config_line(MAX_STR, wmax.x, X_STR); + config_line(MAX_STR, wmax.y, Y_STR); + config_line(MAX_STR, wmax.z, Z_STR); + config_line(SIZE_STR, wmax.x - wmin.x, X_STR); + config_line(SIZE_STR, wmax.y - wmin.y, Y_STR); + config_line(SIZE_STR, wmax.z - wmin.z, Z_STR); + + // + // Print and Travel Acceleration + // + #define _ACCEL(A,B) _MIN(planner.settings.max_acceleration_mm_per_s2[A##_AXIS], planner.settings.B) + PGMSTR(P_ACC_STR, "PrintAccel"); + PGMSTR(T_ACC_STR, "TravelAccel"); + config_line(P_ACC_STR, _ACCEL(X, acceleration), X_STR); + config_line(P_ACC_STR, _ACCEL(Y, acceleration), Y_STR); + config_line(P_ACC_STR, _ACCEL(Z, acceleration), Z_STR); + config_line(T_ACC_STR, _ACCEL(X, travel_acceleration), X_STR); + config_line(T_ACC_STR, _ACCEL(Y, travel_acceleration), Y_STR); + config_line(T_ACC_STR, _ACCEL(Z, travel_acceleration), Z_STR); + + config_prefix(PSTR("PrinterType")); + SERIAL_ECHOLNPGM( + TERN_(DELTA, "Delta") + TERN_(IS_SCARA, "SCARA") + TERN_(IS_CORE, "Core") + TERN_(MARKFORGED_XY, "MarkForged") + TERN_(IS_CARTESIAN, "Cartesian") + ); + + // + // Heated Bed + // + config_line(PSTR("HeatedBed"), ENABLED(HAS_HEATED_BED)); + #if HAS_HEATED_BED + config_line(PSTR("MaxBedTemp"), BED_MAX_TARGET); + #endif + + // + // Per-Extruder settings + // + config_line(PSTR("NumExtruder"), EXTRUDERS); + #if EXTRUDERS + LOOP_L_N(e, EXTRUDERS) { + config_line_e(e, JERK_STR, TERN(HAS_LINEAR_E_JERK, planner.max_e_jerk[E_INDEX_N(e)], TERN(HAS_CLASSIC_JERK, planner.max_jerk.e, DEFAULT_EJERK))); + config_line_e(e, PSTR("MaxSpeed"), planner.settings.max_feedrate_mm_s[E_AXIS_N(e)]); + config_line_e(e, PSTR("Acceleration"), planner.settings.max_acceleration_mm_per_s2[E_AXIS_N(e)]); + config_line_e(e, PSTR("Diameter"), TERN(NO_VOLUMETRICS, DEFAULT_NOMINAL_FILAMENT_DIA, planner.filament_size[e])); + config_line_e(e, PSTR("MaxTemp"), thermalManager.heater_maxtemp[e]); + } + #endif +} + +#endif diff --git a/Marlin/src/gcode/host/M876.cpp b/Marlin/src/gcode/host/M876.cpp new file mode 100644 index 0000000..0d8256c --- /dev/null +++ b/Marlin/src/gcode/host/M876.cpp @@ -0,0 +1,39 @@ +/** + * Marlin 3D Printer Firmware + * Copyright (c) 2020 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 . + * + */ +#include "../../inc/MarlinConfig.h" + +#if ENABLED(HOST_PROMPT_SUPPORT) && DISABLED(EMERGENCY_PARSER) + +#include "../../feature/host_actions.h" +#include "../gcode.h" +#include "../../MarlinCore.h" + +/** + * M876: Handle Prompt Response + */ +void GcodeSuite::M876() { + + if (parser.seenval('S')) host_response_handler((uint8_t)parser.value_int()); + +} + +#endif // HOST_PROMPT_SUPPORT && !EMERGENCY_PARSER -- cgit v1.2.3