My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.

pinsDebug.h 19KB

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