My Marlin configs for Fabrikator Mini and CTC i3 Pro B
選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。

gcode.h 11KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323
  1. /**
  2. * Marlin 3D Printer Firmware
  3. * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  4. *
  5. * Based on Sprinter and grbl.
  6. * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  7. *
  8. * This program is free software: you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation, either version 3 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  20. *
  21. */
  22. /**
  23. * gcode.h - Parser for a GCode line, providing a parameter interface.
  24. * Codes like M149 control the way the GCode parser behaves,
  25. * so settings for these codes are located in this class.
  26. */
  27. #ifndef GCODE_H
  28. #define GCODE_H
  29. #include "enum.h"
  30. #include "types.h"
  31. #include "MarlinConfig.h"
  32. //#define DEBUG_GCODE_PARSER
  33. #if ENABLED(DEBUG_GCODE_PARSER)
  34. #if ENABLED(AUTO_BED_LEVELING_UBL)
  35. extern char* hex_address(const void * const w);
  36. #else
  37. #include "hex_print_routines.h"
  38. #endif
  39. #include "serial.h"
  40. #endif
  41. #if ENABLED(INCH_MODE_SUPPORT)
  42. extern bool volumetric_enabled;
  43. #endif
  44. /**
  45. * GCode parser
  46. *
  47. * - Parse a single gcode line for its letter, code, subcode, and parameters
  48. * - FASTER_GCODE_PARSER:
  49. * - Flags existing params (1 bit each)
  50. * - Stores value offsets (1 byte each)
  51. * - Provide accessors for parameters:
  52. * - Parameter exists
  53. * - Parameter has value
  54. * - Parameter value in different units and types
  55. */
  56. class GCodeParser {
  57. private:
  58. static char *value_ptr; // Set by seen, used to fetch the value
  59. #if ENABLED(FASTER_GCODE_PARSER)
  60. static byte codebits[4]; // Parameters pre-scanned
  61. static uint8_t param[26]; // For A-Z, offsets into command args
  62. #else
  63. static char *command_args; // Args start here, for slow scan
  64. #endif
  65. public:
  66. // Global states for GCode-level units features
  67. #if ENABLED(INCH_MODE_SUPPORT)
  68. static float linear_unit_factor, volumetric_unit_factor;
  69. #endif
  70. #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
  71. static TempUnit input_temp_units;
  72. #endif
  73. // Command line state
  74. static char *command_ptr, // The command, so it can be echoed
  75. *string_arg; // string of command line
  76. static char command_letter; // G, M, or T
  77. static int codenum; // 123
  78. #if USE_GCODE_SUBCODES
  79. static uint8_t subcode; // .1
  80. #endif
  81. #if ENABLED(DEBUG_GCODE_PARSER)
  82. void debug();
  83. #endif
  84. // Reset is done before parsing
  85. static void reset();
  86. // Index so that 'X' falls on index 24
  87. #define PARAM_IND(N) ((N) >> 3)
  88. #define PARAM_BIT(N) ((N) & 0x7)
  89. #define LETTER_OFF(N) ((N) - 'A')
  90. #define LETTER_IND(N) PARAM_IND(LETTER_OFF(N))
  91. #define LETTER_BIT(N) PARAM_BIT(LETTER_OFF(N))
  92. #if ENABLED(FASTER_GCODE_PARSER)
  93. // Set the flag and pointer for a parameter
  94. static void set(const char c, char * const ptr
  95. #if ENABLED(DEBUG_GCODE_PARSER)
  96. , const bool debug=false
  97. #endif
  98. ) {
  99. const uint8_t ind = LETTER_OFF(c);
  100. if (ind >= COUNT(param)) return; // Only A-Z
  101. SBI(codebits[PARAM_IND(ind)], PARAM_BIT(ind)); // parameter exists
  102. param[ind] = ptr ? ptr - command_ptr : 0; // parameter offset or 0
  103. #if ENABLED(DEBUG_GCODE_PARSER)
  104. if (debug) {
  105. SERIAL_ECHOPAIR("Set bit ", (int)PARAM_BIT(ind));
  106. SERIAL_ECHOPAIR(" of index ", (int)PARAM_IND(ind));
  107. SERIAL_ECHOLNPAIR(" | param = ", (int)param[ind]);
  108. }
  109. #endif
  110. }
  111. // Code seen bit was set. If not found, value_ptr is unchanged.
  112. // This allows "if (seen('A')||seen('B'))" to use the last-found value.
  113. static bool seen(const char c) {
  114. const uint8_t ind = LETTER_OFF(c);
  115. if (ind >= COUNT(param)) return false; // Only A-Z
  116. const bool b = TEST(codebits[PARAM_IND(ind)], PARAM_BIT(ind));
  117. if (b) value_ptr = param[ind] ? command_ptr + param[ind] : (char*)NULL;
  118. return b;
  119. }
  120. static bool seen_any() { return codebits[3] || codebits[2] || codebits[1] || codebits[0]; }
  121. #define SEEN_TEST(L) TEST(codebits[LETTER_IND(L)], LETTER_BIT(L))
  122. #else // !FASTER_GCODE_PARSER
  123. // Code is found in the string. If not found, value_ptr is unchanged.
  124. // This allows "if (seen('A')||seen('B'))" to use the last-found value.
  125. static bool seen(const char c) {
  126. const char *p = strchr(command_args, c);
  127. const bool b = !!p;
  128. if (b) value_ptr = DECIMAL_SIGNED(p[1]) ? &p[1] : (char*)NULL;
  129. return b;
  130. }
  131. static bool seen_any() { return *command_args == '\0'; }
  132. #define SEEN_TEST(L) !!strchr(command_args, L)
  133. #endif // !FASTER_GCODE_PARSER
  134. // Seen any axis parameter
  135. static bool seen_axis() {
  136. return SEEN_TEST('X') || SEEN_TEST('Y') || SEEN_TEST('Z') || SEEN_TEST('E');
  137. }
  138. // Populate all fields by parsing a single line of GCode
  139. // This uses 54 bytes of SRAM to speed up seen/value
  140. static void parse(char * p);
  141. // The code value pointer was set
  142. FORCE_INLINE static bool has_value() { return value_ptr != NULL; }
  143. // Seen a parameter with a value
  144. inline static bool seenval(const char c) { return seen(c) && has_value(); }
  145. // Float removes 'E' to prevent scientific notation interpretation
  146. inline static float value_float() {
  147. if (value_ptr) {
  148. char *e = value_ptr;
  149. for (;;) {
  150. const char c = *e;
  151. if (c == '\0' || c == ' ') break;
  152. if (c == 'E' || c == 'e') {
  153. *e = '\0';
  154. const float ret = strtod(value_ptr, NULL);
  155. *e = c;
  156. return ret;
  157. }
  158. ++e;
  159. }
  160. return strtod(value_ptr, NULL);
  161. }
  162. return 0.0;
  163. }
  164. // Code value as a long or ulong
  165. inline static int32_t value_long() { return value_ptr ? strtol(value_ptr, NULL, 10) : 0L; }
  166. inline static uint32_t value_ulong() { return value_ptr ? strtoul(value_ptr, NULL, 10) : 0UL; }
  167. // Code value for use as time
  168. FORCE_INLINE static millis_t value_millis() { return value_ulong(); }
  169. FORCE_INLINE static millis_t value_millis_from_seconds() { return value_float() * 1000UL; }
  170. // Reduce to fewer bits
  171. FORCE_INLINE static int16_t value_int() { return (int16_t)value_long(); }
  172. FORCE_INLINE static uint16_t value_ushort() { return (uint16_t)value_long(); }
  173. inline static uint8_t value_byte() { return (uint8_t)constrain(value_long(), 0, 255); }
  174. // Bool is true with no value or non-zero
  175. inline static bool value_bool() { return !has_value() || value_byte(); }
  176. // Units modes: Inches, Fahrenheit, Kelvin
  177. #if ENABLED(INCH_MODE_SUPPORT)
  178. inline static void set_input_linear_units(const LinearUnit units) {
  179. switch (units) {
  180. case LINEARUNIT_INCH:
  181. linear_unit_factor = 25.4;
  182. break;
  183. case LINEARUNIT_MM:
  184. default:
  185. linear_unit_factor = 1.0;
  186. break;
  187. }
  188. volumetric_unit_factor = POW(linear_unit_factor, 3.0);
  189. }
  190. inline static float axis_unit_factor(const AxisEnum axis) {
  191. return (axis >= E_AXIS && volumetric_enabled ? volumetric_unit_factor : linear_unit_factor);
  192. }
  193. inline static float value_linear_units() { return value_float() * linear_unit_factor; }
  194. inline static float value_axis_units(const AxisEnum axis) { return value_float() * axis_unit_factor(axis); }
  195. inline static float value_per_axis_unit(const AxisEnum axis) { return value_float() / axis_unit_factor(axis); }
  196. #else
  197. FORCE_INLINE static float value_linear_units() { return value_float(); }
  198. FORCE_INLINE static float value_axis_units(const AxisEnum a) { UNUSED(a); return value_float(); }
  199. FORCE_INLINE static float value_per_axis_unit(const AxisEnum a) { UNUSED(a); return value_float(); }
  200. #endif
  201. #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
  202. inline static void set_input_temp_units(TempUnit units) { input_temp_units = units; }
  203. #if ENABLED(ULTIPANEL) && DISABLED(DISABLE_M503)
  204. FORCE_INLINE static char temp_units_code() {
  205. return input_temp_units == TEMPUNIT_K ? 'K' : input_temp_units == TEMPUNIT_F ? 'F' : 'C';
  206. }
  207. FORCE_INLINE static char* temp_units_name() {
  208. return input_temp_units == TEMPUNIT_K ? PSTR("Kelvin") : input_temp_units == TEMPUNIT_F ? PSTR("Fahrenheit") : PSTR("Celsius");
  209. }
  210. inline static float to_temp_units(const float &f) {
  211. switch (input_temp_units) {
  212. case TEMPUNIT_F:
  213. return f * 0.5555555556 + 32.0;
  214. case TEMPUNIT_K:
  215. return f + 273.15;
  216. case TEMPUNIT_C:
  217. default:
  218. return f;
  219. }
  220. }
  221. #endif // ULTIPANEL && !DISABLE_M503
  222. inline static float value_celsius() {
  223. const float f = value_float();
  224. switch (input_temp_units) {
  225. case TEMPUNIT_F:
  226. return (f - 32.0) * 0.5555555556;
  227. case TEMPUNIT_K:
  228. return f - 273.15;
  229. case TEMPUNIT_C:
  230. default:
  231. return f;
  232. }
  233. }
  234. inline static float value_celsius_diff() {
  235. switch (input_temp_units) {
  236. case TEMPUNIT_F:
  237. return value_float() * 0.5555555556;
  238. case TEMPUNIT_C:
  239. case TEMPUNIT_K:
  240. default:
  241. return value_float();
  242. }
  243. }
  244. #else // !TEMPERATURE_UNITS_SUPPORT
  245. FORCE_INLINE static float value_celsius() { return value_float(); }
  246. FORCE_INLINE static float value_celsius_diff() { return value_float(); }
  247. #endif // !TEMPERATURE_UNITS_SUPPORT
  248. FORCE_INLINE static float value_feedrate() { return value_linear_units(); }
  249. void unknown_command_error();
  250. // Provide simple value accessors with default option
  251. FORCE_INLINE static float floatval(const char c, const float dval=0.0) { return seenval(c) ? value_float() : dval; }
  252. FORCE_INLINE static bool boolval(const char c, const bool dval=false) { return seen(c) ? value_bool() : dval; }
  253. FORCE_INLINE static uint8_t byteval(const char c, const uint8_t dval=0) { return seenval(c) ? value_byte() : dval; }
  254. FORCE_INLINE static int16_t intval(const char c, const int16_t dval=0) { return seenval(c) ? value_int() : dval; }
  255. FORCE_INLINE static uint16_t ushortval(const char c, const uint16_t dval=0) { return seenval(c) ? value_ushort() : dval; }
  256. FORCE_INLINE static int32_t longval(const char c, const int32_t dval=0) { return seenval(c) ? value_long() : dval; }
  257. FORCE_INLINE static uint32_t ulongval(const char c, const uint32_t dval=0) { return seenval(c) ? value_ulong() : dval; }
  258. FORCE_INLINE static float linearval(const char c, const float dval=0.0) { return seenval(c) ? value_linear_units() : dval; }
  259. FORCE_INLINE static float celsiusval(const char c, const float dval=0.0) { return seenval(c) ? value_celsius() : dval; }
  260. };
  261. extern GCodeParser parser;
  262. #endif // GCODE_H