Dcodes.cpp 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949
  1. #include "Dcodes.h"
  2. //#include "Marlin.h"
  3. #include "Configuration.h"
  4. #include "language.h"
  5. #include "cmdqueue.h"
  6. #include <stdio.h>
  7. #include <avr/pgmspace.h>
  8. #define SHOW_TEMP_ADC_VALUES
  9. #include "temperature.h"
  10. #define DBG(args...) printf_P(args)
  11. inline void print_hex_nibble(uint8_t val)
  12. {
  13. putchar((val > 9)?(val - 10 + 'a'):(val + '0'));
  14. }
  15. void print_hex_byte(uint8_t val)
  16. {
  17. print_hex_nibble(val >> 4);
  18. print_hex_nibble(val & 15);
  19. }
  20. void print_hex_word(uint16_t val)
  21. {
  22. print_hex_byte(val >> 8);
  23. print_hex_byte(val & 255);
  24. }
  25. void print_eeprom(uint16_t address, uint16_t count, uint8_t countperline = 16)
  26. {
  27. while (count)
  28. {
  29. print_hex_word(address);
  30. putchar(' ');
  31. uint8_t count_line = countperline;
  32. while (count && count_line)
  33. {
  34. putchar(' ');
  35. print_hex_byte(eeprom_read_byte((uint8_t*)address++));
  36. count_line--;
  37. count--;
  38. }
  39. putchar('\n');
  40. }
  41. }
  42. int parse_hex(char* hex, uint8_t* data, int count)
  43. {
  44. int parsed = 0;
  45. while (*hex)
  46. {
  47. if (count && (parsed >= count)) break;
  48. char c = *(hex++);
  49. if (c == ' ') continue;
  50. if (c == '\n') break;
  51. uint8_t val = 0x00;
  52. if ((c >= '0') && (c <= '9')) val |= ((c - '0') << 4);
  53. else if ((c >= 'a') && (c <= 'f')) val |= ((c - 'a' + 10) << 4);
  54. else return -parsed;
  55. c = *(hex++);
  56. if ((c >= '0') && (c <= '9')) val |= (c - '0');
  57. else if ((c >= 'a') && (c <= 'f')) val |= (c - 'a' + 10);
  58. else return -parsed;
  59. data[parsed] = val;
  60. parsed++;
  61. }
  62. return parsed;
  63. }
  64. void print_mem(uint32_t address, uint16_t count, uint8_t type, uint8_t countperline = 16)
  65. {
  66. while (count)
  67. {
  68. if (type == 2)
  69. print_hex_nibble(address >> 16);
  70. print_hex_word(address);
  71. putchar(' ');
  72. uint8_t count_line = countperline;
  73. while (count && count_line)
  74. {
  75. uint8_t data = 0;
  76. switch (type)
  77. {
  78. case 0: data = *((uint8_t*)address++); break;
  79. case 1: data = eeprom_read_byte((uint8_t*)address++); break;
  80. case 2: data = pgm_read_byte_far((uint8_t*)address++); break;
  81. }
  82. putchar(' ');
  83. print_hex_byte(data);
  84. count_line--;
  85. count--;
  86. }
  87. putchar('\n');
  88. }
  89. }
  90. #if defined DEBUG_DCODE3 || defined DEBUG_DCODES
  91. #define EEPROM_SIZE 0x1000
  92. /*!
  93. ### D3 - Read/Write EEPROM <a href="https://reprap.org/wiki/G-code#D3:_Read.2FWrite_EEPROM">D3: Read/Write EEPROM</a>
  94. This command can be used without any additional parameters. It will read the entire eeprom.
  95. #### Usage
  96. D3 [ A | C | X ]
  97. #### Parameters
  98. - `A` - Address (x0000-x0fff)
  99. - `C` - Count (1-4096)
  100. - `X` - Data (hex)
  101. #### Notes
  102. - The hex address needs to be lowercase without the 0 before the x
  103. - Count is decimal
  104. - The hex data needs to be lowercase
  105. */
  106. void dcode_3()
  107. {
  108. DBG(_N("D3 - Read/Write EEPROM\n"));
  109. uint16_t address = 0x0000; //default 0x0000
  110. uint16_t count = EEPROM_SIZE; //default 0x1000 (entire eeprom)
  111. if (code_seen('A')) // Address (0x0000-0x0fff)
  112. address = (strchr_pointer[1] == 'x')?strtol(strchr_pointer + 2, 0, 16):(int)code_value();
  113. if (code_seen('C')) // Count (0x0001-0x1000)
  114. count = (int)code_value();
  115. address &= 0x1fff;
  116. if (count > EEPROM_SIZE) count = EEPROM_SIZE;
  117. if ((address + count) > EEPROM_SIZE) count = EEPROM_SIZE - address;
  118. if (code_seen('X')) // Data
  119. {
  120. uint8_t data[16];
  121. count = parse_hex(strchr_pointer + 1, data, 16);
  122. if (count > 0)
  123. {
  124. for (uint16_t i = 0; i < count; i++)
  125. eeprom_write_byte((uint8_t*)(address + i), data[i]);
  126. printf_P(_N("%d bytes written to EEPROM at address 0x%04x"), count, address);
  127. putchar('\n');
  128. }
  129. else
  130. count = 0;
  131. }
  132. print_mem(address, count, 1);
  133. /* while (count)
  134. {
  135. print_hex_word(address);
  136. putchar(' ');
  137. uint8_t countperline = 16;
  138. while (count && countperline)
  139. {
  140. uint8_t data = eeprom_read_byte((uint8_t*)address++);
  141. putchar(' ');
  142. print_hex_byte(data);
  143. countperline--;
  144. count--;
  145. }
  146. putchar('\n');
  147. }*/
  148. }
  149. #endif //DEBUG_DCODE3
  150. #include "ConfigurationStore.h"
  151. #include "cmdqueue.h"
  152. #include "pat9125.h"
  153. #include "adc.h"
  154. #include "temperature.h"
  155. #include <avr/wdt.h>
  156. #include "bootapp.h"
  157. #if 0
  158. #define FLASHSIZE 0x40000
  159. #define RAMSIZE 0x2000
  160. #define boot_src_addr (*((uint32_t*)(RAMSIZE - 16)))
  161. #define boot_dst_addr (*((uint32_t*)(RAMSIZE - 12)))
  162. #define boot_copy_size (*((uint16_t*)(RAMSIZE - 8)))
  163. #define boot_reserved (*((uint8_t*)(RAMSIZE - 6)))
  164. #define boot_app_flags (*((uint8_t*)(RAMSIZE - 5)))
  165. #define boot_app_magic (*((uint32_t*)(RAMSIZE - 4)))
  166. #define BOOT_APP_FLG_ERASE 0x01
  167. #define BOOT_APP_FLG_COPY 0x02
  168. #define BOOT_APP_FLG_FLASH 0x04
  169. extern float current_temperature_pinda;
  170. extern float axis_steps_per_unit[NUM_AXIS];
  171. #define LOG(args...) printf(args)
  172. #endif //0
  173. #define LOG(args...)
  174. /*!
  175. *
  176. ### D-1 - Endless Loop <a href="https://reprap.org/wiki/G-code#G28:_Move_to_Origin_.28Home.29">D-1: Endless Loop</a>
  177. D-1
  178. *
  179. */
  180. void dcode__1()
  181. {
  182. printf_P(PSTR("D-1 - Endless loop\n"));
  183. // cli();
  184. while (1);
  185. }
  186. #ifdef DEBUG_DCODES
  187. /*!
  188. ### D0 - Reset <a href="https://reprap.org/wiki/G-code#D0:_Reset">D0: Reset</a>
  189. #### Usage
  190. D0 [ B ]
  191. #### Parameters
  192. - `B` - Bootloader
  193. */
  194. void dcode_0()
  195. {
  196. if (*(strchr_pointer + 1) == 0) return;
  197. LOG("D0 - Reset\n");
  198. if (code_seen('B')) //bootloader
  199. {
  200. cli();
  201. wdt_enable(WDTO_15MS);
  202. while(1);
  203. }
  204. else //reset
  205. {
  206. #ifndef _NO_ASM
  207. asm volatile("jmp 0x00000");
  208. #endif //_NO_ASM
  209. }
  210. }
  211. /*!
  212. *
  213. ### D1 - Clear EEPROM and RESET <a href="https://reprap.org/wiki/G-code#D1:_Clear_EEPROM_and_RESET">D1: Clear EEPROM and RESET</a>
  214. D1
  215. *
  216. */
  217. void dcode_1()
  218. {
  219. LOG("D1 - Clear EEPROM and RESET\n");
  220. cli();
  221. for (int i = 0; i < 8192; i++)
  222. eeprom_write_byte((unsigned char*)i, (unsigned char)0xff);
  223. wdt_enable(WDTO_15MS);
  224. while(1);
  225. }
  226. /*!
  227. ### D2 - Read/Write RAM <a href="https://reprap.org/wiki/G-code#D2:_Read.2FWrite_RAM">D3: Read/Write RAM</a>
  228. This command can be used without any additional parameters. It will read the entire RAM.
  229. #### Usage
  230. D2 [ A | C | X ]
  231. #### Parameters
  232. - `A` - Address (x0000-x1fff)
  233. - `C` - Count (1-8192)
  234. - `X` - Data
  235. #### Notes
  236. - The hex address needs to be lowercase without the 0 before the x
  237. - Count is decimal
  238. - The hex data needs to be lowercase
  239. */
  240. void dcode_2()
  241. {
  242. LOG("D2 - Read/Write RAM\n");
  243. uint16_t address = 0x0000; //default 0x0000
  244. uint16_t count = 0x2000; //default 0x2000 (entire ram)
  245. if (code_seen('A')) // Address (0x0000-0x1fff)
  246. address = (strchr_pointer[1] == 'x')?strtol(strchr_pointer + 2, 0, 16):(int)code_value();
  247. if (code_seen('C')) // Count (0x0001-0x2000)
  248. count = (int)code_value();
  249. address &= 0x1fff;
  250. if (count > 0x2000) count = 0x2000;
  251. if ((address + count) > 0x2000) count = 0x2000 - address;
  252. if (code_seen('X')) // Data
  253. {
  254. uint8_t data[16];
  255. count = parse_hex(strchr_pointer + 1, data, 16);
  256. if (count > 0)
  257. {
  258. for (uint16_t i = 0; i < count; i++)
  259. *((uint8_t*)(address + i)) = data[i];
  260. LOG("%d bytes written to RAM at address %04x", count, address);
  261. }
  262. else
  263. count = 0;
  264. }
  265. print_mem(address, count, 0);
  266. /* while (count)
  267. {
  268. print_hex_word(address);
  269. putchar(' ');
  270. uint8_t countperline = 16;
  271. while (count && countperline)
  272. {
  273. uint8_t data = *((uint8_t*)address++);
  274. putchar(' ');
  275. print_hex_byte(data);
  276. countperline--;
  277. count--;
  278. }
  279. putchar('\n');
  280. }*/
  281. }
  282. /*!
  283. ### D4 - Read/Write PIN <a href="https://reprap.org/wiki/G-code#D4:_Read.2FWrite_PIN">D4: Read/Write PIN</a>
  284. To read the digital value of a pin you need only to define the pin number.
  285. #### Usage
  286. D4 [ P | F | V ]
  287. #### Parameters
  288. - `P` - Pin (0-255)
  289. - `F` - Function in/out (0/1)
  290. - `V` - Value (0/1)
  291. */
  292. void dcode_4()
  293. {
  294. LOG("D4 - Read/Write PIN\n");
  295. if (code_seen('P')) // Pin (0-255)
  296. {
  297. int pin = (int)code_value();
  298. if ((pin >= 0) && (pin <= 255))
  299. {
  300. if (code_seen('F')) // Function in/out (0/1)
  301. {
  302. int fnc = (int)code_value();
  303. if (fnc == 0) pinMode(pin, INPUT);
  304. else if (fnc == 1) pinMode(pin, OUTPUT);
  305. }
  306. if (code_seen('V')) // Value (0/1)
  307. {
  308. int val = (int)code_value();
  309. if (val == 0) digitalWrite(pin, LOW);
  310. else if (val == 1) digitalWrite(pin, HIGH);
  311. }
  312. else
  313. {
  314. int val = (digitalRead(pin) != LOW)?1:0;
  315. printf("PIN%d=%d", pin, val);
  316. }
  317. }
  318. }
  319. }
  320. #endif //DEBUG_DCODES
  321. #if defined DEBUG_DCODE5 || defined DEBUG_DCODES
  322. /*!
  323. ### D5 - Read/Write FLASH <a href="https://reprap.org/wiki/G-code#D5:_Read.2FWrite_FLASH">D5: Read/Write Flash</a>
  324. This command can be used without any additional parameters. It will read the 1kb FLASH.
  325. #### Usage
  326. D5 [ A | C | X | E ]
  327. #### Parameters
  328. - `A` - Address (x00000-x3ffff)
  329. - `C` - Count (1-8192)
  330. - `X` - Data (hex)
  331. - `E` - Erase
  332. #### Notes
  333. - The hex address needs to be lowercase without the 0 before the x
  334. - Count is decimal
  335. - The hex data needs to be lowercase
  336. */
  337. void dcode_5()
  338. {
  339. printf_P(PSTR("D5 - Read/Write FLASH\n"));
  340. uint32_t address = 0x0000; //default 0x0000
  341. uint16_t count = 0x0400; //default 0x0400 (1kb block)
  342. if (code_seen('A')) // Address (0x00000-0x3ffff)
  343. address = (strchr_pointer[1] == 'x')?strtol(strchr_pointer + 2, 0, 16):(int)code_value();
  344. if (code_seen('C')) // Count (0x0001-0x2000)
  345. count = (int)code_value();
  346. address &= 0x3ffff;
  347. if (count > 0x2000) count = 0x2000;
  348. if ((address + count) > 0x40000) count = 0x40000 - address;
  349. bool bErase = false;
  350. bool bCopy = false;
  351. if (code_seen('E')) //Erase
  352. bErase = true;
  353. uint8_t data[16];
  354. if (code_seen('X')) // Data
  355. {
  356. count = parse_hex(strchr_pointer + 1, data, 16);
  357. if (count > 0) bCopy = true;
  358. }
  359. if (bErase || bCopy)
  360. {
  361. if (bErase)
  362. {
  363. printf_P(PSTR("%d bytes of FLASH at address %05x will be erased\n"), count, address);
  364. }
  365. if (bCopy)
  366. {
  367. printf_P(PSTR("%d bytes will be written to FLASH at address %05x\n"), count, address);
  368. }
  369. cli();
  370. boot_app_magic = 0x55aa55aa;
  371. boot_app_flags = (bErase?(BOOT_APP_FLG_ERASE):0) | (bCopy?(BOOT_APP_FLG_COPY):0);
  372. boot_copy_size = (uint16_t)count;
  373. boot_dst_addr = (uint32_t)address;
  374. boot_src_addr = (uint32_t)(&data);
  375. bootapp_print_vars();
  376. wdt_enable(WDTO_15MS);
  377. while(1);
  378. }
  379. while (count)
  380. {
  381. print_hex_nibble(address >> 16);
  382. print_hex_word(address);
  383. putchar(' ');
  384. uint8_t countperline = 16;
  385. while (count && countperline)
  386. {
  387. uint8_t data = pgm_read_byte_far((uint8_t*)address++);
  388. putchar(' ');
  389. print_hex_byte(data);
  390. countperline--;
  391. count--;
  392. }
  393. putchar('\n');
  394. }
  395. }
  396. #endif //DEBUG_DCODE5
  397. #ifdef DEBUG_DCODES
  398. /*!
  399. ### D6 - Read/Write external FLASH <a href="https://reprap.org/wiki/G-code#D6:_Read.2FWrite_external_FLASH">D6: Read/Write external Flash</a>
  400. Reserved
  401. */
  402. void dcode_6()
  403. {
  404. LOG("D6 - Read/Write external FLASH\n");
  405. }
  406. /*!
  407. ### D7 - Read/Write Bootloader <a href="https://reprap.org/wiki/G-code#D7:_Read.2FWrite_Bootloader">D7: Read/Write Bootloader</a>
  408. Reserved
  409. */
  410. void dcode_7()
  411. {
  412. LOG("D7 - Read/Write Bootloader\n");
  413. /*
  414. cli();
  415. boot_app_magic = 0x55aa55aa;
  416. boot_app_flags = BOOT_APP_FLG_ERASE | BOOT_APP_FLG_COPY | BOOT_APP_FLG_FLASH;
  417. boot_copy_size = (uint16_t)0xc00;
  418. boot_src_addr = (uint32_t)0x0003e400;
  419. boot_dst_addr = (uint32_t)0x0003f400;
  420. wdt_enable(WDTO_15MS);
  421. while(1);
  422. */
  423. }
  424. /*!
  425. ### D8 - Read/Write PINDA <a href="https://reprap.org/wiki/G-code#D8:_Read.2FWrite_PINDA">D8: Read/Write PINDA</a>
  426. #### Usage
  427. D8 [ ? | ! | P | Z ]
  428. #### Parameters
  429. - `?` - Read PINDA temperature shift values
  430. - `!` - Reset PINDA temperature shift values to default
  431. - `P` - Pinda temperature [C]
  432. - `Z` - Z Offset [mm]
  433. */
  434. void dcode_8()
  435. {
  436. printf_P(PSTR("D8 - Read/Write PINDA\n"));
  437. uint8_t cal_status = calibration_status_pinda();
  438. float temp_pinda = current_temperature_pinda;
  439. float offset_z = temp_compensation_pinda_thermistor_offset(temp_pinda);
  440. if ((strchr_pointer[1+1] == '?') || (strchr_pointer[1+1] == 0))
  441. {
  442. printf_P(PSTR("cal_status=%d\n"), cal_status?1:0);
  443. for (uint8_t i = 0; i < 6; i++)
  444. {
  445. uint16_t offs = 0;
  446. if (i > 0) offs = eeprom_read_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + (i - 1));
  447. float foffs = ((float)offs) / cs.axis_steps_per_unit[Z_AXIS];
  448. offs = 1000 * foffs;
  449. printf_P(PSTR("temp_pinda=%dC temp_shift=%dum\n"), 35 + i * 5, offs);
  450. }
  451. }
  452. else if (strchr_pointer[1+1] == '!')
  453. {
  454. cal_status = 1;
  455. eeprom_write_byte((uint8_t*)EEPROM_CALIBRATION_STATUS_PINDA, cal_status);
  456. eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 0, 8); //40C - 20um - 8usteps
  457. eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 1, 24); //45C - 60um - 24usteps
  458. eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 2, 48); //50C - 120um - 48usteps
  459. eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 3, 80); //55C - 200um - 80usteps
  460. eeprom_write_word(((uint16_t*)EEPROM_PROBE_TEMP_SHIFT) + 4, 120); //60C - 300um - 120usteps
  461. }
  462. else
  463. {
  464. if (code_seen('P')) // Pinda temperature [C]
  465. temp_pinda = code_value();
  466. offset_z = temp_compensation_pinda_thermistor_offset(temp_pinda);
  467. if (code_seen('Z')) // Z Offset [mm]
  468. {
  469. offset_z = code_value();
  470. }
  471. }
  472. printf_P(PSTR("temp_pinda=%d offset_z=%d.%03d\n"), (int)temp_pinda, (int)offset_z, ((int)(1000 * offset_z) % 1000));
  473. }
  474. /*!
  475. ### D9 - Read ADC <a href="https://reprap.org/wiki/G-code#D9:_Read.2FWrite_ADC">D9: Read ADC</a>
  476. #### Usage
  477. D9 [ I | V ]
  478. #### Parameters
  479. - `I` - ADC channel index
  480. - `0` - Heater 0 temperature
  481. - `1` - Heater 1 temperature
  482. - `2` - Bed temperature
  483. - `3` - PINDA temperature
  484. - `4` - PWR voltage
  485. - `5` - Ambient temperature
  486. - `6` - BED voltage
  487. - `V` Value to be written as simulated
  488. */
  489. const char* dcode_9_ADC_name(uint8_t i)
  490. {
  491. switch (i)
  492. {
  493. case 0: return PSTR("TEMP_HEATER0");
  494. case 1: return PSTR("TEMP_HEATER1");
  495. case 2: return PSTR("TEMP_BED");
  496. case 3: return PSTR("TEMP_PINDA");
  497. case 4: return PSTR("VOLT_PWR");
  498. case 5: return PSTR("TEMP_AMBIENT");
  499. case 6: return PSTR("VOLT_BED");
  500. }
  501. return 0;
  502. }
  503. #ifdef AMBIENT_THERMISTOR
  504. extern int current_temperature_raw_ambient;
  505. #endif //AMBIENT_THERMISTOR
  506. #ifdef VOLT_PWR_PIN
  507. extern int current_voltage_raw_pwr;
  508. #endif //VOLT_PWR_PIN
  509. #ifdef VOLT_BED_PIN
  510. extern int current_voltage_raw_bed;
  511. #endif //VOLT_BED_PIN
  512. uint16_t dcode_9_ADC_val(uint8_t i)
  513. {
  514. switch (i)
  515. {
  516. case 0: return current_temperature_raw[0];
  517. case 1: return 0;
  518. case 2: return current_temperature_bed_raw;
  519. case 3: return current_temperature_raw_pinda;
  520. #ifdef VOLT_PWR_PIN
  521. case 4: return current_voltage_raw_pwr;
  522. #endif //VOLT_PWR_PIN
  523. #ifdef AMBIENT_THERMISTOR
  524. case 5: return current_temperature_raw_ambient;
  525. #endif //AMBIENT_THERMISTOR
  526. #ifdef VOLT_BED_PIN
  527. case 6: return current_voltage_raw_bed;
  528. #endif //VOLT_BED_PIN
  529. }
  530. return 0;
  531. }
  532. void dcode_9()
  533. {
  534. printf_P(PSTR("D9 - Read/Write ADC\n"));
  535. if ((strchr_pointer[1+1] == '?') || (strchr_pointer[1+1] == 0))
  536. {
  537. for (uint8_t i = 0; i < ADC_CHAN_CNT; i++)
  538. printf_P(PSTR("\tADC%d=%4d\t(%S)\n"), i, dcode_9_ADC_val(i) >> 4, dcode_9_ADC_name(i));
  539. }
  540. else
  541. {
  542. uint8_t index = 0xff;
  543. if (code_seen('I')) // index (index of used channel, not avr channel index)
  544. index = code_value();
  545. if (index < ADC_CHAN_CNT)
  546. {
  547. if (code_seen('V')) // value to be written as simulated
  548. {
  549. adc_sim_mask |= (1 << index);
  550. adc_values[index] = (((int)code_value()) << 4);
  551. printf_P(PSTR("ADC%d=%4d\n"), index, adc_values[index] >> 4);
  552. }
  553. }
  554. }
  555. }
  556. /*!
  557. ### D10 - Set XYZ calibration = OK <a href="https://reprap.org/wiki/G-code#D10:_Set_XYZ_calibration_.3D_OK">D10: Set XYZ calibration = OK</a>
  558. */
  559. void dcode_10()
  560. {//Tell the printer that XYZ calibration went OK
  561. LOG("D10 - XYZ calibration = OK\n");
  562. calibration_status_store(CALIBRATION_STATUS_LIVE_ADJUST);
  563. }
  564. /*!
  565. ### D12 - Time <a href="https://reprap.org/wiki/G-code#D12:_Time">D12: Time</a>
  566. Writes the current time in the log file.
  567. */
  568. void dcode_12()
  569. {//Time
  570. LOG("D12 - Time\n");
  571. }
  572. #ifdef HEATBED_ANALYSIS
  573. /*!
  574. ### D80 - Bed check <a href="https://reprap.org/wiki/G-code#D80:_Bed_check">D80: Bed check</a>
  575. This command will log data to SD card file "mesh.txt".
  576. #### Usage
  577. D80 [ E | F | G | H | I | J ]
  578. #### Parameters
  579. - `E` - Dimension X (default 40)
  580. - `F` - Dimention Y (default 40)
  581. - `G` - Points X (default 40)
  582. - `H` - Points Y (default 40)
  583. - `I` - Offset X (default 74)
  584. - `J` - Offset Y (default 34)
  585. */
  586. void dcode_80()
  587. {
  588. float dimension_x = 40;
  589. float dimension_y = 40;
  590. int points_x = 40;
  591. int points_y = 40;
  592. float offset_x = 74;
  593. float offset_y = 33;
  594. if (code_seen('E')) dimension_x = code_value();
  595. if (code_seen('F')) dimension_y = code_value();
  596. if (code_seen('G')) {points_x = code_value(); }
  597. if (code_seen('H')) {points_y = code_value(); }
  598. if (code_seen('I')) {offset_x = code_value(); }
  599. if (code_seen('J')) {offset_y = code_value(); }
  600. printf_P(PSTR("DIM X: %f\n"), dimension_x);
  601. printf_P(PSTR("DIM Y: %f\n"), dimension_y);
  602. printf_P(PSTR("POINTS X: %d\n"), points_x);
  603. printf_P(PSTR("POINTS Y: %d\n"), points_y);
  604. printf_P(PSTR("OFFSET X: %f\n"), offset_x);
  605. printf_P(PSTR("OFFSET Y: %f\n"), offset_y);
  606. bed_check(dimension_x,dimension_y,points_x,points_y,offset_x,offset_y);
  607. }
  608. /*!
  609. ### D81 - Bed analysis <a href="https://reprap.org/wiki/G-code#D81:_Bed_analysis">D80: Bed analysis</a>
  610. This command will log data to SD card file "wldsd.txt".
  611. #### Usage
  612. D81 [ E | F | G | H | I | J ]
  613. #### Parameters
  614. - `E` - Dimension X (default 40)
  615. - `F` - Dimention Y (default 40)
  616. - `G` - Points X (default 40)
  617. - `H` - Points Y (default 40)
  618. - `I` - Offset X (default 74)
  619. - `J` - Offset Y (default 34)
  620. */
  621. void dcode_81()
  622. {
  623. float dimension_x = 40;
  624. float dimension_y = 40;
  625. int points_x = 40;
  626. int points_y = 40;
  627. float offset_x = 74;
  628. float offset_y = 33;
  629. if (code_seen('E')) dimension_x = code_value();
  630. if (code_seen('F')) dimension_y = code_value();
  631. if (code_seen("G")) { strchr_pointer+=1; points_x = code_value(); }
  632. if (code_seen("H")) { strchr_pointer+=1; points_y = code_value(); }
  633. if (code_seen("I")) { strchr_pointer+=1; offset_x = code_value(); }
  634. if (code_seen("J")) { strchr_pointer+=1; offset_y = code_value(); }
  635. bed_analysis(dimension_x,dimension_y,points_x,points_y,offset_x,offset_y);
  636. }
  637. #endif //HEATBED_ANALYSIS
  638. /*!
  639. ### D106 - Print measured fan speed for different pwm values <a href="https://reprap.org/wiki/G-code#D106:_Print_measured_fan_speed_for_different_pwm_values">D106: Print measured fan speed for different pwm values</a>
  640. */
  641. void dcode_106()
  642. {
  643. for (int i = 255; i > 0; i = i - 5) {
  644. fanSpeed = i;
  645. //delay_keep_alive(2000);
  646. for (int j = 0; j < 100; j++) {
  647. delay_keep_alive(100);
  648. }
  649. printf_P(_N("%d: %d\n"), i, fan_speed[1]);
  650. }
  651. }
  652. #ifdef TMC2130
  653. #include "planner.h"
  654. #include "tmc2130.h"
  655. extern void st_synchronize();
  656. /*!
  657. ### D2130 - Trinamic stepper controller <a href="https://reprap.org/wiki/G-code#D2130:_Trinamic_stepper_controller">D2130: Trinamic stepper controller</a>
  658. @todo Please review by owner of the code. RepRap Wiki Gcode needs to be updated after review of owner as well.
  659. #### Usage
  660. D2130 [ Axis | Command | Subcommand | Value ]
  661. #### Parameters
  662. - Axis
  663. - `X` - X stepper driver
  664. - `Y` - Y stepper driver
  665. - `Z` - Z stepper driver
  666. - `E` - Extruder stepper driver
  667. - Commands
  668. - `0` - Current off
  669. - `1` - Current on
  670. - `+` - Single step
  671. - `-` - Single step oposite direction
  672. - `NNN` - Value sereval steps
  673. - `?` - Read register
  674. - Subcommands for read register
  675. - `mres` - Micro step resolution. More information in datasheet '5.5.2 CHOPCONF – Chopper Configuration'
  676. - `step` - Step
  677. - `mscnt` - Microstep counter. More information in datasheet '5.5 Motor Driver Registers'
  678. - `mscuract` - Actual microstep current for motor. More information in datasheet '5.5 Motor Driver Registers'
  679. - `wave` - Microstep linearity compensation curve
  680. - `!` - Set register
  681. - Subcommands for set register
  682. - `mres` - Micro step resolution
  683. - `step` - Step
  684. - `wave` - Microstep linearity compensation curve
  685. - Values for set register
  686. - `0, 180 --> 250` - Off
  687. - `0.9 --> 1.25` - Valid values (recommended is 1.1)
  688. - `@` - Home calibrate axis
  689. Examples:
  690. D2130E?wave
  691. Print extruder microstep linearity compensation curve
  692. D2130E!wave0
  693. Disable extruder linearity compensation curve, (sine curve is used)
  694. D2130E!wave220
  695. (sin(x))^1.1 extruder microstep compensation curve used
  696. Notes:
  697. For more information see https://www.trinamic.com/fileadmin/assets/Products/ICs_Documents/TMC2130_datasheet.pdf
  698. *
  699. */
  700. void dcode_2130()
  701. {
  702. printf_P(PSTR("D2130 - TMC2130\n"));
  703. uint8_t axis = 0xff;
  704. switch (strchr_pointer[1+4])
  705. {
  706. case 'X': axis = X_AXIS; break;
  707. case 'Y': axis = Y_AXIS; break;
  708. case 'Z': axis = Z_AXIS; break;
  709. case 'E': axis = E_AXIS; break;
  710. }
  711. if (axis != 0xff)
  712. {
  713. char ch_axis = strchr_pointer[1+4];
  714. if (strchr_pointer[1+5] == '0') { tmc2130_set_pwr(axis, 0); }
  715. else if (strchr_pointer[1+5] == '1') { tmc2130_set_pwr(axis, 1); }
  716. else if (strchr_pointer[1+5] == '+')
  717. {
  718. if (strchr_pointer[1+6] == 0)
  719. {
  720. tmc2130_set_dir(axis, 0);
  721. tmc2130_do_step(axis);
  722. }
  723. else
  724. {
  725. uint8_t steps = atoi(strchr_pointer + 1 + 6);
  726. tmc2130_do_steps(axis, steps, 0, 1000);
  727. }
  728. }
  729. else if (strchr_pointer[1+5] == '-')
  730. {
  731. if (strchr_pointer[1+6] == 0)
  732. {
  733. tmc2130_set_dir(axis, 1);
  734. tmc2130_do_step(axis);
  735. }
  736. else
  737. {
  738. uint8_t steps = atoi(strchr_pointer + 1 + 6);
  739. tmc2130_do_steps(axis, steps, 1, 1000);
  740. }
  741. }
  742. else if (strchr_pointer[1+5] == '?')
  743. {
  744. if (strcmp(strchr_pointer + 7, "mres") == 0) printf_P(PSTR("%c mres=%d\n"), ch_axis, tmc2130_mres[axis]);
  745. else if (strcmp(strchr_pointer + 7, "step") == 0) printf_P(PSTR("%c step=%d\n"), ch_axis, tmc2130_rd_MSCNT(axis) >> tmc2130_mres[axis]);
  746. else if (strcmp(strchr_pointer + 7, "mscnt") == 0) printf_P(PSTR("%c MSCNT=%d\n"), ch_axis, tmc2130_rd_MSCNT(axis));
  747. else if (strcmp(strchr_pointer + 7, "mscuract") == 0)
  748. {
  749. uint32_t val = tmc2130_rd_MSCURACT(axis);
  750. int curA = (val & 0xff);
  751. int curB = ((val >> 16) & 0xff);
  752. if ((val << 7) & 0x8000) curA -= 256;
  753. if ((val >> 9) & 0x8000) curB -= 256;
  754. printf_P(PSTR("%c MSCURACT=0x%08lx A=%d B=%d\n"), ch_axis, val, curA, curB);
  755. }
  756. else if (strcmp(strchr_pointer + 7, "wave") == 0)
  757. {
  758. tmc2130_get_wave(axis, 0, stdout);
  759. }
  760. }
  761. else if (strchr_pointer[1+5] == '!')
  762. {
  763. if (strncmp(strchr_pointer + 7, "step", 4) == 0)
  764. {
  765. uint8_t step = atoi(strchr_pointer + 11);
  766. uint16_t res = tmc2130_get_res(axis);
  767. tmc2130_goto_step(axis, step & (4*res - 1), 2, 1000, res);
  768. }
  769. else if (strncmp(strchr_pointer + 7, "mres", 4) == 0)
  770. {
  771. uint8_t mres = strchr_pointer[11] - '0';
  772. if (mres <= 8)
  773. {
  774. st_synchronize();
  775. uint16_t res = tmc2130_get_res(axis);
  776. uint16_t res_new = tmc2130_mres2usteps(mres);
  777. tmc2130_set_res(axis, res_new);
  778. if (res_new > res)
  779. cs.axis_steps_per_unit[axis] *= (res_new / res);
  780. else
  781. cs.axis_steps_per_unit[axis] /= (res / res_new);
  782. }
  783. }
  784. else if (strncmp(strchr_pointer + 7, "wave", 4) == 0)
  785. {
  786. uint8_t fac1000 = atoi(strchr_pointer + 11) & 0xffff;
  787. if (fac1000 < TMC2130_WAVE_FAC1000_MIN) fac1000 = 0;
  788. if (fac1000 > TMC2130_WAVE_FAC1000_MAX) fac1000 = TMC2130_WAVE_FAC1000_MAX;
  789. tmc2130_set_wave(axis, 247, fac1000);
  790. tmc2130_wave_fac[axis] = fac1000;
  791. }
  792. }
  793. else if (strchr_pointer[1+5] == '@')
  794. {
  795. tmc2130_home_calibrate(axis);
  796. }
  797. }
  798. }
  799. #endif //TMC2130
  800. #ifdef PAT9125
  801. /*!
  802. ### D9125 - PAT9125 filament sensor <a href="https://reprap.org/wiki/G-code#D9:_Read.2FWrite_ADC">D9125: PAT9125 filament sensor</a>
  803. #### Usage
  804. D9125 [ ? | ! | R | X | Y | L ]
  805. #### Parameters
  806. - `?` - Print values
  807. - `!` - Print values
  808. - `R` - Resolution. Not active in code
  809. - `X` - X values
  810. - `Y` - Y values
  811. - `L` - Activate filament sensor log
  812. */
  813. void dcode_9125()
  814. {
  815. LOG("D9125 - PAT9125\n");
  816. if ((strchr_pointer[1+4] == '?') || (strchr_pointer[1+4] == 0))
  817. {
  818. // printf("res_x=%d res_y=%d x=%d y=%d b=%d s=%d\n", pat9125_xres, pat9125_yres, pat9125_x, pat9125_y, pat9125_b, pat9125_s);
  819. printf("x=%d y=%d b=%d s=%d\n", pat9125_x, pat9125_y, pat9125_b, pat9125_s);
  820. return;
  821. }
  822. if (strchr_pointer[1+4] == '!')
  823. {
  824. pat9125_update();
  825. printf("x=%d y=%d b=%d s=%d\n", pat9125_x, pat9125_y, pat9125_b, pat9125_s);
  826. return;
  827. }
  828. /*
  829. if (code_seen('R'))
  830. {
  831. unsigned char res = (int)code_value();
  832. LOG("pat9125_init(xres=yres=%d)=%d\n", res, pat9125_init(res, res));
  833. }
  834. */
  835. if (code_seen('X'))
  836. {
  837. pat9125_x = (int)code_value();
  838. LOG("pat9125_x=%d\n", pat9125_x);
  839. }
  840. if (code_seen('Y'))
  841. {
  842. pat9125_y = (int)code_value();
  843. LOG("pat9125_y=%d\n", pat9125_y);
  844. }
  845. #ifdef DEBUG_FSENSOR_LOG
  846. if (code_seen('L'))
  847. {
  848. fsensor_log = (int)code_value();
  849. LOG("fsensor_log=%d\n", fsensor_log);
  850. }
  851. #endif //DEBUG_FSENSOR_LOG
  852. }
  853. #endif //PAT9125
  854. #endif //DEBUG_DCODES