My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

pinsDebug.h 16KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492
  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. bool endstop_monitor_flag = false;
  23. #define NAME_FORMAT "%-28s" // one place to specify the format of all the sources of names
  24. // "-" left justify, "28" minimum width of name, pad with blanks
  25. #define IS_ANALOG(P) ((P) >= analogInputToDigitalPin(0) && ((P) <= analogInputToDigitalPin(15) || (P) <= analogInputToDigitalPin(7)))
  26. #define AVR_ATmega2560_FAMILY (defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2561__))
  27. #define AVR_AT90USB1286_FAMILY (defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1286P__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB646P__) || defined(__AVR_AT90USB647__))
  28. #define AVR_ATmega1284_FAMILY (defined(__AVR_ATmega644__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284P__))
  29. /**
  30. * This routine minimizes RAM usage by creating a FLASH resident array to
  31. * store the pin names, pin numbers and analog/digital flag.
  32. *
  33. * Creating the array in FLASH is a two pass process. The first pass puts the
  34. * name strings into FLASH. The second pass actually creates the array.
  35. *
  36. * Both passes use the same pin list. The list contains two macro names. The
  37. * actual macro definitions are changed depending on which pass is being done.
  38. *
  39. */
  40. // first pass - put the name strings into FLASH
  41. #define _ADD_PIN_2(PIN_NAME, ENTRY_NAME) static const unsigned char ENTRY_NAME[] PROGMEM = { PIN_NAME };
  42. #define _ADD_PIN(PIN_NAME, COUNTER) _ADD_PIN_2(PIN_NAME, entry_NAME_##COUNTER)
  43. #define REPORT_NAME_DIGITAL(NAME, COUNTER) _ADD_PIN(#NAME, COUNTER)
  44. #define REPORT_NAME_ANALOG(NAME, COUNTER) _ADD_PIN(#NAME, COUNTER)
  45. #include "pinsDebug_list.h"
  46. #line 56
  47. // manually add pins that have names that are macros which don't play well with these macros
  48. #if SERIAL_PORT == 0 && (AVR_ATmega2560_FAMILY || AVR_ATmega1284_FAMILY)
  49. static const char RXD_NAME[] PROGMEM = { "RXD" };
  50. static const char TXD_NAME[] PROGMEM = { "TXD" };
  51. #endif
  52. /////////////////////////////////////////////////////////////////////////////
  53. // second pass - create the array
  54. #undef _ADD_PIN_2
  55. #undef _ADD_PIN
  56. #undef REPORT_NAME_DIGITAL
  57. #undef REPORT_NAME_ANALOG
  58. #define _ADD_PIN_2(ENTRY_NAME, NAME, IS_DIGITAL) { (const char*)ENTRY_NAME, (const char*)NAME, (const char*)IS_DIGITAL },
  59. #define _ADD_PIN(NAME, COUNTER, IS_DIGITAL) _ADD_PIN_2(entry_NAME_##COUNTER, NAME, IS_DIGITAL)
  60. #define REPORT_NAME_DIGITAL(NAME, COUNTER) _ADD_PIN(NAME, COUNTER, (uint8_t)1)
  61. #define REPORT_NAME_ANALOG(NAME, COUNTER) _ADD_PIN(analogInputToDigitalPin(NAME), COUNTER, 0)
  62. const char* const pin_array[][3] PROGMEM = {
  63. /**
  64. * [pin name] [pin number] [is digital or analog] 1 = digital, 0 = analog
  65. * Each entry takes up 6 bytes in FLASH:
  66. * 2 byte pointer to location of the name string
  67. * 2 bytes containing the pin number
  68. * analog pin numbers were convereted to digital when the array was created
  69. * 2 bytes containing the digital/analog bool flag
  70. */
  71. // manually add pins ...
  72. #if SERIAL_PORT == 0
  73. #if AVR_ATmega2560_FAMILY
  74. { RXD_NAME, "0", "1" },
  75. { TXD_NAME, "1", "1" },
  76. #elif AVR_ATmega1284_FAMILY
  77. { RXD_NAME, "8", "1" },
  78. { TXD_NAME, "9", "1" },
  79. #endif
  80. #endif
  81. #include "pinsDebug_list.h"
  82. #line 101
  83. };
  84. #define n_array (sizeof(pin_array) / sizeof(char*)) / 3
  85. #ifndef TIMER1B
  86. // working with Teensyduino extension so need to re-define some things
  87. #include "pinsDebug_Teensyduino.h"
  88. #endif
  89. #define PWM_PRINT(V) do{ sprintf(buffer, "PWM: %4d", V); SERIAL_ECHO(buffer); }while(0)
  90. #define PWM_CASE(N,Z) \
  91. case TIMER##N##Z: \
  92. if (TCCR##N##A & (_BV(COM##N##Z##1) | _BV(COM##N##Z##0))) { \
  93. PWM_PRINT(OCR##N##Z); \
  94. return true; \
  95. } else return false
  96. /**
  97. * Print a pin's PWM status.
  98. * Return true if it's currently a PWM pin.
  99. */
  100. static bool pwm_status(uint8_t pin) {
  101. char buffer[20]; // for the sprintf statements
  102. switch (digitalPinToTimer(pin)) {
  103. #if defined(TCCR0A) && defined(COM0A1)
  104. #ifdef TIMER0A
  105. PWM_CASE(0, A);
  106. #endif
  107. PWM_CASE(0, B);
  108. #endif
  109. #if defined(TCCR1A) && defined(COM1A1)
  110. PWM_CASE(1, A);
  111. PWM_CASE(1, B);
  112. #if defined(COM1C1) && defined(TIMER1C)
  113. PWM_CASE(1, C);
  114. #endif
  115. #endif
  116. #if defined(TCCR2A) && defined(COM2A1)
  117. PWM_CASE(2, A);
  118. PWM_CASE(2, B);
  119. #endif
  120. #if defined(TCCR3A) && defined(COM3A1)
  121. PWM_CASE(3, A);
  122. PWM_CASE(3, B);
  123. #ifdef COM3C1
  124. PWM_CASE(3, C);
  125. #endif
  126. #endif
  127. #ifdef TCCR4A
  128. PWM_CASE(4, A);
  129. PWM_CASE(4, B);
  130. PWM_CASE(4, C);
  131. #endif
  132. #if defined(TCCR5A) && defined(COM5A1)
  133. PWM_CASE(5, A);
  134. PWM_CASE(5, B);
  135. PWM_CASE(5, C);
  136. #endif
  137. case NOT_ON_TIMER:
  138. default:
  139. return false;
  140. }
  141. SERIAL_PROTOCOL_SP(2);
  142. } // pwm_status
  143. const volatile uint8_t* const PWM_other[][3] PROGMEM = {
  144. { &TCCR0A, &TCCR0B, &TIMSK0 },
  145. { &TCCR1A, &TCCR1B, &TIMSK1 },
  146. #if defined(TCCR2A) && defined(COM2A1)
  147. { &TCCR2A, &TCCR2B, &TIMSK2 },
  148. #endif
  149. #if defined(TCCR3A) && defined(COM3A1)
  150. { &TCCR3A, &TCCR3B, &TIMSK3 },
  151. #endif
  152. #ifdef TCCR4A
  153. { &TCCR4A, &TCCR4B, &TIMSK4 },
  154. #endif
  155. #if defined(TCCR5A) && defined(COM5A1)
  156. { &TCCR5A, &TCCR5B, &TIMSK5 },
  157. #endif
  158. };
  159. const volatile uint8_t* const PWM_OCR[][3] PROGMEM = {
  160. #ifdef TIMER0A
  161. { &OCR0A, &OCR0B, 0 },
  162. #else
  163. { 0, &OCR0B, 0 },
  164. #endif
  165. #if defined(COM1C1) && defined(TIMER1C)
  166. { (const uint8_t*)&OCR1A, (const uint8_t*)&OCR1B, (const uint8_t*)&OCR1C },
  167. #else
  168. { (const uint8_t*)&OCR1A, (const uint8_t*)&OCR1B, 0 },
  169. #endif
  170. #if defined(TCCR2A) && defined(COM2A1)
  171. { &OCR2A, &OCR2B, 0 },
  172. #endif
  173. #if defined(TCCR3A) && defined(COM3A1)
  174. #ifdef COM3C1
  175. { (const uint8_t*)&OCR3A, (const uint8_t*)&OCR3B, (const uint8_t*)&OCR3C },
  176. #else
  177. { (const uint8_t*)&OCR3A, (const uint8_t*)&OCR3B, 0 },
  178. #endif
  179. #endif
  180. #ifdef TCCR4A
  181. { (const uint8_t*)&OCR4A, (const uint8_t*)&OCR4B, (const uint8_t*)&OCR4C },
  182. #endif
  183. #if defined(TCCR5A) && defined(COM5A1)
  184. { (const uint8_t*)&OCR5A, (const uint8_t*)&OCR5B, (const uint8_t*)&OCR5C },
  185. #endif
  186. };
  187. #define TCCR_A(T) pgm_read_word(&PWM_other[T][0])
  188. #define TCCR_B(T) pgm_read_word(&PWM_other[T][1])
  189. #define TIMSK(T) pgm_read_word(&PWM_other[T][2])
  190. #define CS_0 0
  191. #define CS_1 1
  192. #define CS_2 2
  193. #define WGM_0 0
  194. #define WGM_1 1
  195. #define WGM_2 3
  196. #define WGM_3 4
  197. #define TOIE 0
  198. #define OCR_VAL(T, L) pgm_read_word(&PWM_OCR[T][L])
  199. static void err_is_counter() { SERIAL_PROTOCOLPGM(" non-standard PWM mode"); }
  200. static void err_is_interrupt() { SERIAL_PROTOCOLPGM(" compare interrupt enabled"); }
  201. static void err_prob_interrupt() { SERIAL_PROTOCOLPGM(" overflow interrupt enabled"); }
  202. void com_print(uint8_t N, uint8_t Z) {
  203. uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
  204. SERIAL_PROTOCOLPGM(" COM");
  205. SERIAL_PROTOCOLCHAR(N + '0');
  206. switch (Z) {
  207. case 'A':
  208. SERIAL_PROTOCOLPAIR("A: ", ((*TCCRA & (_BV(7) | _BV(6))) >> 6));
  209. break;
  210. case 'B':
  211. SERIAL_PROTOCOLPAIR("B: ", ((*TCCRA & (_BV(5) | _BV(4))) >> 4));
  212. break;
  213. case 'C':
  214. SERIAL_PROTOCOLPAIR("C: ", ((*TCCRA & (_BV(3) | _BV(2))) >> 2));
  215. break;
  216. }
  217. }
  218. void timer_prefix(uint8_t T, char L, uint8_t N) { // T - timer L - pwm N - WGM bit layout
  219. char buffer[20]; // for the sprintf statements
  220. uint8_t *TCCRB = (uint8_t*)TCCR_B(T);
  221. uint8_t *TCCRA = (uint8_t*)TCCR_A(T);
  222. uint8_t WGM = (((*TCCRB & _BV(WGM_2)) >> 1) | (*TCCRA & (_BV(WGM_0) | _BV(WGM_1))));
  223. if (N == 4) WGM |= ((*TCCRB & _BV(WGM_3)) >> 1);
  224. SERIAL_PROTOCOLPGM(" TIMER");
  225. SERIAL_PROTOCOLCHAR(T + '0');
  226. SERIAL_PROTOCOLCHAR(L);
  227. SERIAL_PROTOCOL_SP(3);
  228. if (N == 3) {
  229. uint8_t *OCRVAL8 = (uint8_t*)OCR_VAL(T, L - 'A');
  230. PWM_PRINT(*OCRVAL8);
  231. }
  232. else {
  233. uint16_t *OCRVAL16 = (uint16_t*)OCR_VAL(T, L - 'A');
  234. PWM_PRINT(*OCRVAL16);
  235. }
  236. SERIAL_PROTOCOLPAIR(" WGM: ", WGM);
  237. com_print(T,L);
  238. SERIAL_PROTOCOLPAIR(" CS: ", (*TCCRB & (_BV(CS_0) | _BV(CS_1) | _BV(CS_2)) ));
  239. SERIAL_PROTOCOLPGM(" TCCR");
  240. SERIAL_PROTOCOLCHAR(T + '0');
  241. SERIAL_PROTOCOLPAIR("A: ", *TCCRA);
  242. SERIAL_PROTOCOLPGM(" TCCR");
  243. SERIAL_PROTOCOLCHAR(T + '0');
  244. SERIAL_PROTOCOLPAIR("B: ", *TCCRB);
  245. uint8_t *TMSK = (uint8_t*)TIMSK(T);
  246. SERIAL_PROTOCOLPGM(" TIMSK");
  247. SERIAL_PROTOCOLCHAR(T + '0');
  248. SERIAL_PROTOCOLPAIR(": ", *TMSK);
  249. uint8_t OCIE = L - 'A' + 1;
  250. if (N == 3) { if (WGM == 0 || WGM == 2 || WGM == 4 || WGM == 6) err_is_counter(); }
  251. else { if (WGM == 0 || WGM == 4 || WGM == 12 || WGM == 13) err_is_counter(); }
  252. if (TEST(*TMSK, OCIE)) err_is_interrupt();
  253. if (TEST(*TMSK, TOIE)) err_prob_interrupt();
  254. }
  255. static void pwm_details(uint8_t pin) {
  256. switch (digitalPinToTimer(pin)) {
  257. #if defined(TCCR0A) && defined(COM0A1)
  258. #ifdef TIMER0A
  259. case TIMER0A: timer_prefix(0, 'A', 3); break;
  260. #endif
  261. case TIMER0B: timer_prefix(0, 'B', 3); break;
  262. #endif
  263. #if defined(TCCR1A) && defined(COM1A1)
  264. case TIMER1A: timer_prefix(1, 'A', 4); break;
  265. case TIMER1B: timer_prefix(1, 'B', 4); break;
  266. #if defined(COM1C1) && defined(TIMER1C)
  267. case TIMER1C: timer_prefix(1, 'C', 4); break;
  268. #endif
  269. #endif
  270. #if defined(TCCR2A) && defined(COM2A1)
  271. case TIMER2A: timer_prefix(2, 'A', 3); break;
  272. case TIMER2B: timer_prefix(2, 'B', 3); break;
  273. #endif
  274. #if defined(TCCR3A) && defined(COM3A1)
  275. case TIMER3A: timer_prefix(3, 'A', 4); break;
  276. case TIMER3B: timer_prefix(3, 'B', 4); break;
  277. #ifdef COM3C1
  278. case TIMER3C: timer_prefix(3, 'C', 4); break;
  279. #endif
  280. #endif
  281. #ifdef TCCR4A
  282. case TIMER4A: timer_prefix(4, 'A', 4); break;
  283. case TIMER4B: timer_prefix(4, 'B', 4); break;
  284. case TIMER4C: timer_prefix(4, 'C', 4); break;
  285. #endif
  286. #if defined(TCCR5A) && defined(COM5A1)
  287. case TIMER5A: timer_prefix(5, 'A', 4); break;
  288. case TIMER5B: timer_prefix(5, 'B', 4); break;
  289. case TIMER5C: timer_prefix(5, 'C', 4); break;
  290. #endif
  291. case NOT_ON_TIMER: break;
  292. }
  293. SERIAL_PROTOCOLPGM(" ");
  294. // on pins that have two PWMs, print info on second PWM
  295. #if AVR_ATmega2560_FAMILY || AVR_AT90USB1286_FAMILY
  296. // looking for port B7 - PWMs 0A and 1C
  297. if ( ('B' == digitalPinToPort(pin) + 64) && (0x80 == digitalPinToBitMask(pin))) {
  298. #ifndef TEENSYDUINO_IDE
  299. SERIAL_PROTOCOLPGM("\n .");
  300. SERIAL_PROTOCOL_SP(18);
  301. SERIAL_PROTOCOLPGM("TIMER1C is also tied to this pin");
  302. SERIAL_PROTOCOL_SP(13);
  303. timer_prefix(1, 'C', 4);
  304. #else
  305. SERIAL_PROTOCOLPGM("\n .");
  306. SERIAL_PROTOCOL_SP(18);
  307. SERIAL_PROTOCOLPGM("TIMER0A is also tied to this pin");
  308. SERIAL_PROTOCOL_SP(13);
  309. timer_prefix(0, 'A', 3);
  310. #endif
  311. }
  312. #endif
  313. } // pwm_details
  314. bool get_pinMode(int8_t pin) { return *portModeRegister(digitalPinToPort(pin)) & digitalPinToBitMask(pin); }
  315. #ifndef digitalRead_mod // use Teensyduino's version of digitalRead - it doesn't disable the PWMs
  316. int digitalRead_mod(int8_t pin) { // same as digitalRead except the PWM stop section has been removed
  317. uint8_t port = digitalPinToPort(pin);
  318. return (port != NOT_A_PIN) && (*portInputRegister(port) & digitalPinToBitMask(pin)) ? HIGH : LOW;
  319. }
  320. #endif
  321. void print_port(int8_t pin) { // print port number
  322. #ifdef digitalPinToPort
  323. SERIAL_PROTOCOLPGM(" Port: ");
  324. uint8_t x = digitalPinToPort(pin) + 64;
  325. SERIAL_CHAR(x);
  326. uint8_t temp = digitalPinToBitMask(pin);
  327. for (x = '0'; x < '9' && temp != 1; x++) temp >>= 1;
  328. SERIAL_CHAR(x);
  329. #else
  330. SERIAL_PROTOCOL_SP(10);
  331. #endif
  332. }
  333. // pretty report with PWM info
  334. inline void report_pin_state_extended(int8_t pin, bool ignore, bool extended = true) {
  335. uint8_t temp_char;
  336. char *name_mem_pointer;
  337. char buffer[30]; // for the sprintf statements
  338. bool found = false,
  339. multi_name_pin = false;
  340. for (uint8_t x = 0; x < n_array; x++) { // scan entire array and report all instances of this pin
  341. if (pgm_read_byte(&pin_array[x][1]) == pin) {
  342. if (found) multi_name_pin = true;
  343. found = true;
  344. if (!multi_name_pin) { // report digitial and analog pin number only on the first time through
  345. sprintf(buffer, "PIN: %3d ", pin); // digital pin number
  346. SERIAL_ECHO(buffer);
  347. print_port(pin);
  348. if (IS_ANALOG(pin)) {
  349. sprintf(buffer, " (A%2d) ", int(pin - analogInputToDigitalPin(0))); // analog pin number
  350. SERIAL_ECHO(buffer);
  351. }
  352. else SERIAL_ECHO_SP(8); // add padding if not an analog pin
  353. }
  354. else {
  355. SERIAL_CHAR('.');
  356. SERIAL_ECHO_SP(25); // add padding if not the first instance found
  357. }
  358. name_mem_pointer = (char*)pgm_read_word(&pin_array[x][0]);
  359. for (uint8_t y = 0; y < 28; y++) { // always print pin name
  360. temp_char = pgm_read_byte(name_mem_pointer + y);
  361. if (temp_char != 0) MYSERIAL.write(temp_char);
  362. else {
  363. for (uint8_t i = 0; i < 28 - y; i++) MYSERIAL.write(' ');
  364. break;
  365. }
  366. }
  367. if (pin_is_protected(pin) && !ignore)
  368. SERIAL_ECHOPGM("protected ");
  369. else {
  370. if (!(pgm_read_byte(&pin_array[x][2]))) {
  371. sprintf(buffer, "Analog in = %5d", analogRead(pin - analogInputToDigitalPin(0)));
  372. SERIAL_ECHO(buffer);
  373. }
  374. else {
  375. if (!get_pinMode(pin)) {
  376. //pinMode(pin, INPUT_PULLUP); // make sure input isn't floating - stopped doing this
  377. // because this could interfere with inductive/capacitive
  378. // sensors (high impedance voltage divider) and with PT100 amplifier
  379. SERIAL_PROTOCOLPAIR("Input = ", digitalRead_mod(pin));
  380. }
  381. else if (pwm_status(pin)) {
  382. // do nothing
  383. }
  384. else SERIAL_PROTOCOLPAIR("Output = ", digitalRead_mod(pin));
  385. }
  386. if (!multi_name_pin && extended) pwm_details(pin); // report PWM capabilities only on the first pass & only if doing an extended report
  387. }
  388. SERIAL_EOL;
  389. } // end of IF
  390. } // end of for loop
  391. if (!found) {
  392. sprintf(buffer, "PIN: %3d ", pin);
  393. SERIAL_ECHO(buffer);
  394. print_port(pin);
  395. if (IS_ANALOG(pin)) {
  396. sprintf(buffer, " (A%2d) ", int(pin - analogInputToDigitalPin(0))); // analog pin number
  397. SERIAL_ECHO(buffer);
  398. }
  399. else
  400. SERIAL_ECHO_SP(8); // add padding if not an analog pin
  401. SERIAL_ECHOPGM("<unused/unknown>");
  402. if (get_pinMode(pin)) {
  403. SERIAL_PROTOCOL_SP(12);
  404. SERIAL_PROTOCOLPAIR("Output = ", digitalRead_mod(pin));
  405. }
  406. else {
  407. if (IS_ANALOG(pin)) {
  408. sprintf(buffer, " Analog in = %5d", analogRead(pin - analogInputToDigitalPin(0)));
  409. SERIAL_ECHO(buffer);
  410. }
  411. else
  412. SERIAL_ECHO_SP(9); // add padding if not an analog pin
  413. SERIAL_PROTOCOLPAIR(" Input = ", digitalRead_mod(pin));
  414. }
  415. //if (!pwm_status(pin)) SERIAL_CHAR(' '); // add padding if it's not a PWM pin
  416. if (extended) pwm_details(pin); // report PWM capabilities only if doing an extended report
  417. SERIAL_EOL;
  418. }
  419. }
  420. inline void report_pin_state(int8_t pin) {
  421. report_pin_state_extended(pin, false, false);
  422. }