fsensor.cpp 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598
  1. //! @file
  2. #include "Marlin.h"
  3. #include "fsensor.h"
  4. #include <avr/pgmspace.h>
  5. #include "pat9125.h"
  6. #include "stepper.h"
  7. #include "planner.h"
  8. #include "fastio.h"
  9. #include "io_atmega2560.h"
  10. #include "cmdqueue.h"
  11. #include "ultralcd.h"
  12. #include "ConfigurationStore.h"
  13. #include "mmu.h"
  14. #include "cardreader.h"
  15. //! @name Basic parameters
  16. //! @{
  17. #define FSENSOR_CHUNK_LEN 0.64F //!< filament sensor chunk length 0.64mm
  18. #define FSENSOR_ERR_MAX 17 //!< filament sensor maximum error count for runout detection
  19. //! @}
  20. //! @name Optical quality measurement parameters
  21. //! @{
  22. #define FSENSOR_OQ_MAX_ES 6 //!< maximum error sum while loading (length ~64mm = 100chunks)
  23. #define FSENSOR_OQ_MAX_EM 2 //!< maximum error counter value while loading
  24. #define FSENSOR_OQ_MIN_YD 2 //!< minimum yd per chunk (applied to avg value)
  25. #define FSENSOR_OQ_MAX_YD 200 //!< maximum yd per chunk (applied to avg value)
  26. #define FSENSOR_OQ_MAX_PD 4 //!< maximum positive deviation (= yd_max/yd_avg)
  27. #define FSENSOR_OQ_MAX_ND 5 //!< maximum negative deviation (= yd_avg/yd_min)
  28. #define FSENSOR_OQ_MAX_SH 13 //!< maximum shutter value
  29. //! @}
  30. const char ERRMSG_PAT9125_NOT_RESP[] PROGMEM = "PAT9125 not responding (%d)!\n";
  31. // PJ7 can not be used (does not have PinChangeInterrupt possibility)
  32. #define FSENSOR_INT_PIN 75 //!< filament sensor interrupt pin PJ4
  33. #define FSENSOR_INT_PIN_MASK 0x10 //!< filament sensor interrupt pin mask (bit4)
  34. #define FSENSOR_INT_PIN_PIN_REG PINJ // PIN register @ PJ4
  35. #define FSENSOR_INT_PIN_VECT PCINT1_vect // PinChange ISR @ PJ4
  36. #define FSENSOR_INT_PIN_PCMSK_REG PCMSK1 // PinChangeMaskRegister @ PJ4
  37. #define FSENSOR_INT_PIN_PCMSK_BIT PCINT13 // PinChange Interrupt / PinChange Enable Mask @ PJ4
  38. #define FSENSOR_INT_PIN_PCICR_BIT PCIE1 // PinChange Interrupt Enable / Flag @ PJ4
  39. //uint8_t fsensor_int_pin = FSENSOR_INT_PIN;
  40. uint8_t fsensor_int_pin_old = 0;
  41. int16_t fsensor_chunk_len = 0;
  42. //! enabled = initialized and sampled every chunk event
  43. bool fsensor_enabled = true;
  44. //! runout watching is done in fsensor_update (called from main loop)
  45. bool fsensor_watch_runout = true;
  46. //! not responding - is set if any communication error occurred during initialization or readout
  47. bool fsensor_not_responding = false;
  48. //! printing saved
  49. bool fsensor_printing_saved = false;
  50. //! enable/disable quality meassurement
  51. bool fsensor_oq_meassure_enabled = false;
  52. //! as explained in the CHECK_FSENSOR macro: this flag is set to true when fsensor posts
  53. //! the M600 into the command queue, which elliminates the hazard of having posted multiple M600's
  54. //! before the first one gets read and started processing.
  55. //! Btw., the IR fsensor could do up to 6 posts before the command queue managed to start processing the first M600 ;)
  56. static bool fsensor_m600_enqueued = false;
  57. //! number of errors, updated in ISR
  58. uint8_t fsensor_err_cnt = 0;
  59. //! variable for accumulating step count (updated callbacks from stepper and ISR)
  60. int16_t fsensor_st_cnt = 0;
  61. //! last dy value from pat9125 sensor (used in ISR)
  62. int16_t fsensor_dy_old = 0;
  63. //! log flag: 0=log disabled, 1=log enabled
  64. uint8_t fsensor_log = 1;
  65. //! @name filament autoload variables
  66. //! @{
  67. //! autoload feature enabled
  68. bool fsensor_autoload_enabled = true;
  69. //! autoload watching enable/disable flag
  70. bool fsensor_watch_autoload = false;
  71. //
  72. uint16_t fsensor_autoload_y;
  73. //
  74. uint8_t fsensor_autoload_c;
  75. //
  76. uint32_t fsensor_autoload_last_millis;
  77. //
  78. uint8_t fsensor_autoload_sum;
  79. //! @}
  80. //! @name filament optical quality measurement variables
  81. //! @{
  82. //! Measurement enable/disable flag
  83. bool fsensor_oq_meassure = false;
  84. //! skip-chunk counter, for accurate measurement is necessary to skip first chunk...
  85. uint8_t fsensor_oq_skipchunk;
  86. //! number of samples from start of measurement
  87. uint8_t fsensor_oq_samples;
  88. //! sum of steps in positive direction movements
  89. uint16_t fsensor_oq_st_sum;
  90. //! sum of deltas in positive direction movements
  91. uint16_t fsensor_oq_yd_sum;
  92. //! sum of errors during measurement
  93. uint16_t fsensor_oq_er_sum;
  94. //! max error counter value during measurement
  95. uint8_t fsensor_oq_er_max;
  96. //! minimum delta value
  97. int16_t fsensor_oq_yd_min;
  98. //! maximum delta value
  99. int16_t fsensor_oq_yd_max;
  100. //! sum of shutter value
  101. uint16_t fsensor_oq_sh_sum;
  102. //! @}
  103. void fsensor_stop_and_save_print(void)
  104. {
  105. printf_P(PSTR("fsensor_stop_and_save_print\n"));
  106. stop_and_save_print_to_ram(0, 0); //XYZE - no change
  107. }
  108. void fsensor_restore_print_and_continue(void)
  109. {
  110. printf_P(PSTR("fsensor_restore_print_and_continue\n"));
  111. fsensor_watch_runout = true;
  112. fsensor_err_cnt = 0;
  113. fsensor_m600_enqueued = false;
  114. restore_print_from_ram_and_continue(0); //XYZ = orig, E - no change
  115. }
  116. void fsensor_init(void)
  117. {
  118. #ifdef PAT9125
  119. uint8_t pat9125 = pat9125_init();
  120. printf_P(PSTR("PAT9125_init:%hhu\n"), pat9125);
  121. #endif //PAT9125
  122. uint8_t fsensor = eeprom_read_byte((uint8_t*)EEPROM_FSENSOR);
  123. fsensor_autoload_enabled=eeprom_read_byte((uint8_t*)EEPROM_FSENS_AUTOLOAD_ENABLED);
  124. #ifdef PAT9125
  125. uint8_t oq_meassure_enabled = eeprom_read_byte((uint8_t*)EEPROM_FSENS_OQ_MEASS_ENABLED);
  126. fsensor_oq_meassure_enabled = (oq_meassure_enabled == 1)?true:false;
  127. fsensor_chunk_len = (int16_t)(FSENSOR_CHUNK_LEN * cs.axis_steps_per_unit[E_AXIS]);
  128. if (!pat9125)
  129. {
  130. fsensor = 0; //disable sensor
  131. fsensor_not_responding = true;
  132. }
  133. else
  134. fsensor_not_responding = false;
  135. #endif //PAT9125
  136. if (fsensor)
  137. fsensor_enable();
  138. else
  139. fsensor_disable();
  140. printf_P(PSTR("FSensor %S\n"), (fsensor_enabled?PSTR("ENABLED"):PSTR("DISABLED\n")));
  141. if (check_for_ir_sensor()) ir_sensor_detected = true;
  142. }
  143. bool fsensor_enable(void)
  144. {
  145. #ifdef PAT9125
  146. if (mmu_enabled == false) { //filament sensor is pat9125, enable only if it is working
  147. uint8_t pat9125 = pat9125_init();
  148. printf_P(PSTR("PAT9125_init:%hhu\n"), pat9125);
  149. if (pat9125)
  150. fsensor_not_responding = false;
  151. else
  152. fsensor_not_responding = true;
  153. fsensor_enabled = pat9125 ? true : false;
  154. fsensor_watch_runout = true;
  155. fsensor_oq_meassure = false;
  156. fsensor_err_cnt = 0;
  157. fsensor_dy_old = 0;
  158. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, fsensor_enabled ? 0x01 : 0x00);
  159. FSensorStateMenu = fsensor_enabled ? 1 : 0;
  160. }
  161. else //filament sensor is FINDA, always enable
  162. {
  163. fsensor_enabled = true;
  164. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x01);
  165. FSensorStateMenu = 1;
  166. }
  167. #else // PAT9125
  168. fsensor_enabled = true;
  169. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x01);
  170. FSensorStateMenu = 1;
  171. #endif // PAT9125
  172. return fsensor_enabled;
  173. }
  174. void fsensor_disable(void)
  175. {
  176. fsensor_enabled = false;
  177. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x00);
  178. FSensorStateMenu = 0;
  179. }
  180. void fsensor_autoload_set(bool State)
  181. {
  182. #ifdef PAT9125
  183. if (!State) fsensor_autoload_check_stop();
  184. #endif //PAT9125
  185. fsensor_autoload_enabled = State;
  186. eeprom_update_byte((unsigned char *)EEPROM_FSENS_AUTOLOAD_ENABLED, fsensor_autoload_enabled);
  187. }
  188. void pciSetup(byte pin)
  189. {
  190. // !!! "digitalPinTo?????bit()" does not provide the correct results for some MCU pins
  191. *digitalPinToPCMSK(pin) |= bit (digitalPinToPCMSKbit(pin)); // enable pin
  192. PCIFR |= bit (digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
  193. PCICR |= bit (digitalPinToPCICRbit(pin)); // enable interrupt for the group
  194. }
  195. #ifdef PAT9125
  196. void fsensor_autoload_check_start(void)
  197. {
  198. // puts_P(_N("fsensor_autoload_check_start\n"));
  199. if (!fsensor_enabled) return;
  200. if (!fsensor_autoload_enabled) return;
  201. if (fsensor_watch_autoload) return;
  202. if (!pat9125_update_y()) //update sensor
  203. {
  204. fsensor_disable();
  205. fsensor_not_responding = true;
  206. fsensor_watch_autoload = false;
  207. printf_P(ERRMSG_PAT9125_NOT_RESP, 3);
  208. return;
  209. }
  210. puts_P(_N("fsensor_autoload_check_start - autoload ENABLED\n"));
  211. fsensor_autoload_y = pat9125_y; //save current y value
  212. fsensor_autoload_c = 0; //reset number of changes counter
  213. fsensor_autoload_sum = 0;
  214. fsensor_autoload_last_millis = _millis();
  215. fsensor_watch_runout = false;
  216. fsensor_watch_autoload = true;
  217. fsensor_err_cnt = 0;
  218. }
  219. void fsensor_autoload_check_stop(void)
  220. {
  221. // puts_P(_N("fsensor_autoload_check_stop\n"));
  222. if (!fsensor_enabled) return;
  223. // puts_P(_N("fsensor_autoload_check_stop 1\n"));
  224. if (!fsensor_autoload_enabled) return;
  225. // puts_P(_N("fsensor_autoload_check_stop 2\n"));
  226. if (!fsensor_watch_autoload) return;
  227. puts_P(_N("fsensor_autoload_check_stop - autoload DISABLED\n"));
  228. fsensor_autoload_sum = 0;
  229. fsensor_watch_autoload = false;
  230. fsensor_watch_runout = true;
  231. fsensor_err_cnt = 0;
  232. }
  233. #endif //PAT9125
  234. bool fsensor_check_autoload(void)
  235. {
  236. if (!fsensor_enabled) return false;
  237. if (!fsensor_autoload_enabled) return false;
  238. if (ir_sensor_detected) {
  239. if (digitalRead(IR_SENSOR_PIN) == 1) {
  240. fsensor_watch_autoload = true;
  241. }
  242. else if (fsensor_watch_autoload == true) {
  243. fsensor_watch_autoload = false;
  244. return true;
  245. }
  246. }
  247. #ifdef PAT9125
  248. if (!fsensor_watch_autoload)
  249. {
  250. fsensor_autoload_check_start();
  251. return false;
  252. }
  253. #if 0
  254. uint8_t fsensor_autoload_c_old = fsensor_autoload_c;
  255. #endif
  256. if ((_millis() - fsensor_autoload_last_millis) < 25) return false;
  257. fsensor_autoload_last_millis = _millis();
  258. if (!pat9125_update_y()) //update sensor
  259. {
  260. fsensor_disable();
  261. fsensor_not_responding = true;
  262. printf_P(ERRMSG_PAT9125_NOT_RESP, 2);
  263. return false;
  264. }
  265. int16_t dy = pat9125_y - fsensor_autoload_y;
  266. if (dy) //? dy value is nonzero
  267. {
  268. if (dy > 0) //? delta-y value is positive (inserting)
  269. {
  270. fsensor_autoload_sum += dy;
  271. fsensor_autoload_c += 3; //increment change counter by 3
  272. }
  273. else if (fsensor_autoload_c > 1)
  274. fsensor_autoload_c -= 2; //decrement change counter by 2
  275. fsensor_autoload_y = pat9125_y; //save current value
  276. }
  277. else if (fsensor_autoload_c > 0)
  278. fsensor_autoload_c--;
  279. if (fsensor_autoload_c == 0) fsensor_autoload_sum = 0;
  280. #if 0
  281. puts_P(_N("fsensor_check_autoload\n"));
  282. if (fsensor_autoload_c != fsensor_autoload_c_old)
  283. printf_P(PSTR("fsensor_check_autoload dy=%d c=%d sum=%d\n"), dy, fsensor_autoload_c, fsensor_autoload_sum);
  284. #endif
  285. // if ((fsensor_autoload_c >= 15) && (fsensor_autoload_sum > 30))
  286. if ((fsensor_autoload_c >= 12) && (fsensor_autoload_sum > 20))
  287. {
  288. // puts_P(_N("fsensor_check_autoload = true !!!\n"));
  289. return true;
  290. }
  291. #endif //PAT9125
  292. return false;
  293. }
  294. void fsensor_oq_meassure_set(bool State)
  295. {
  296. fsensor_oq_meassure_enabled = State;
  297. eeprom_update_byte((unsigned char *)EEPROM_FSENS_OQ_MEASS_ENABLED, fsensor_oq_meassure_enabled);
  298. }
  299. void fsensor_oq_meassure_start(uint8_t skip)
  300. {
  301. if (!fsensor_enabled) return;
  302. if (!fsensor_oq_meassure_enabled) return;
  303. printf_P(PSTR("fsensor_oq_meassure_start\n"));
  304. fsensor_oq_skipchunk = skip;
  305. fsensor_oq_samples = 0;
  306. fsensor_oq_st_sum = 0;
  307. fsensor_oq_yd_sum = 0;
  308. fsensor_oq_er_sum = 0;
  309. fsensor_oq_er_max = 0;
  310. fsensor_oq_yd_min = FSENSOR_OQ_MAX_YD;
  311. fsensor_oq_yd_max = 0;
  312. fsensor_oq_sh_sum = 0;
  313. pat9125_update();
  314. pat9125_y = 0;
  315. fsensor_watch_runout = false;
  316. fsensor_oq_meassure = true;
  317. }
  318. void fsensor_oq_meassure_stop(void)
  319. {
  320. if (!fsensor_enabled) return;
  321. if (!fsensor_oq_meassure_enabled) return;
  322. printf_P(PSTR("fsensor_oq_meassure_stop, %hhu samples\n"), fsensor_oq_samples);
  323. printf_P(_N(" st_sum=%u yd_sum=%u er_sum=%u er_max=%hhu\n"), fsensor_oq_st_sum, fsensor_oq_yd_sum, fsensor_oq_er_sum, fsensor_oq_er_max);
  324. printf_P(_N(" yd_min=%u yd_max=%u yd_avg=%u sh_avg=%u\n"), fsensor_oq_yd_min, fsensor_oq_yd_max, (uint16_t)((uint32_t)fsensor_oq_yd_sum * fsensor_chunk_len / fsensor_oq_st_sum), (uint16_t)(fsensor_oq_sh_sum / fsensor_oq_samples));
  325. fsensor_oq_meassure = false;
  326. fsensor_watch_runout = true;
  327. fsensor_err_cnt = 0;
  328. }
  329. const char _OK[] PROGMEM = "OK";
  330. const char _NG[] PROGMEM = "NG!";
  331. bool fsensor_oq_result(void)
  332. {
  333. if (!fsensor_enabled) return true;
  334. if (!fsensor_oq_meassure_enabled) return true;
  335. printf_P(_N("fsensor_oq_result\n"));
  336. bool res_er_sum = (fsensor_oq_er_sum <= FSENSOR_OQ_MAX_ES);
  337. printf_P(_N(" er_sum = %u %S\n"), fsensor_oq_er_sum, (res_er_sum?_OK:_NG));
  338. bool res_er_max = (fsensor_oq_er_max <= FSENSOR_OQ_MAX_EM);
  339. printf_P(_N(" er_max = %hhu %S\n"), fsensor_oq_er_max, (res_er_max?_OK:_NG));
  340. uint8_t yd_avg = ((uint32_t)fsensor_oq_yd_sum * fsensor_chunk_len / fsensor_oq_st_sum);
  341. bool res_yd_avg = (yd_avg >= FSENSOR_OQ_MIN_YD) && (yd_avg <= FSENSOR_OQ_MAX_YD);
  342. printf_P(_N(" yd_avg = %hhu %S\n"), yd_avg, (res_yd_avg?_OK:_NG));
  343. bool res_yd_max = (fsensor_oq_yd_max <= (yd_avg * FSENSOR_OQ_MAX_PD));
  344. printf_P(_N(" yd_max = %u %S\n"), fsensor_oq_yd_max, (res_yd_max?_OK:_NG));
  345. bool res_yd_min = (fsensor_oq_yd_min >= (yd_avg / FSENSOR_OQ_MAX_ND));
  346. printf_P(_N(" yd_min = %u %S\n"), fsensor_oq_yd_min, (res_yd_min?_OK:_NG));
  347. uint16_t yd_dev = (fsensor_oq_yd_max - yd_avg) + (yd_avg - fsensor_oq_yd_min);
  348. printf_P(_N(" yd_dev = %u\n"), yd_dev);
  349. uint16_t yd_qua = 10 * yd_avg / (yd_dev + 1);
  350. printf_P(_N(" yd_qua = %u %S\n"), yd_qua, ((yd_qua >= 8)?_OK:_NG));
  351. uint8_t sh_avg = (fsensor_oq_sh_sum / fsensor_oq_samples);
  352. bool res_sh_avg = (sh_avg <= FSENSOR_OQ_MAX_SH);
  353. if (yd_qua >= 8) res_sh_avg = true;
  354. printf_P(_N(" sh_avg = %hhu %S\n"), sh_avg, (res_sh_avg?_OK:_NG));
  355. bool res = res_er_sum && res_er_max && res_yd_avg && res_yd_max && res_yd_min && res_sh_avg;
  356. printf_P(_N("fsensor_oq_result %S\n"), (res?_OK:_NG));
  357. return res;
  358. }
  359. #ifdef PAT9125
  360. ISR(FSENSOR_INT_PIN_VECT)
  361. {
  362. if (mmu_enabled || ir_sensor_detected) return;
  363. if (!((fsensor_int_pin_old ^ FSENSOR_INT_PIN_PIN_REG) & FSENSOR_INT_PIN_MASK)) return;
  364. fsensor_int_pin_old = FSENSOR_INT_PIN_PIN_REG;
  365. static bool _lock = false;
  366. if (_lock) return;
  367. _lock = true;
  368. int st_cnt = fsensor_st_cnt;
  369. fsensor_st_cnt = 0;
  370. sei();
  371. uint8_t old_err_cnt = fsensor_err_cnt;
  372. uint8_t pat9125_res = fsensor_oq_meassure?pat9125_update():pat9125_update_y();
  373. if (!pat9125_res)
  374. {
  375. fsensor_disable();
  376. fsensor_not_responding = true;
  377. printf_P(ERRMSG_PAT9125_NOT_RESP, 1);
  378. }
  379. if (st_cnt != 0)
  380. { //movement
  381. if (st_cnt > 0) //positive movement
  382. {
  383. if (pat9125_y < 0)
  384. {
  385. if (fsensor_err_cnt)
  386. fsensor_err_cnt += 2;
  387. else
  388. fsensor_err_cnt++;
  389. }
  390. else if (pat9125_y > 0)
  391. {
  392. if (fsensor_err_cnt)
  393. fsensor_err_cnt--;
  394. }
  395. else //(pat9125_y == 0)
  396. if (((fsensor_dy_old <= 0) || (fsensor_err_cnt)) && (st_cnt > (fsensor_chunk_len >> 1)))
  397. fsensor_err_cnt++;
  398. if (fsensor_oq_meassure)
  399. {
  400. if (fsensor_oq_skipchunk)
  401. {
  402. fsensor_oq_skipchunk--;
  403. fsensor_err_cnt = 0;
  404. }
  405. else
  406. {
  407. if (st_cnt == fsensor_chunk_len)
  408. {
  409. if (pat9125_y > 0) if (fsensor_oq_yd_min > pat9125_y) fsensor_oq_yd_min = (fsensor_oq_yd_min + pat9125_y) / 2;
  410. if (pat9125_y >= 0) if (fsensor_oq_yd_max < pat9125_y) fsensor_oq_yd_max = (fsensor_oq_yd_max + pat9125_y) / 2;
  411. }
  412. fsensor_oq_samples++;
  413. fsensor_oq_st_sum += st_cnt;
  414. if (pat9125_y > 0) fsensor_oq_yd_sum += pat9125_y;
  415. if (fsensor_err_cnt > old_err_cnt)
  416. fsensor_oq_er_sum += (fsensor_err_cnt - old_err_cnt);
  417. if (fsensor_oq_er_max < fsensor_err_cnt)
  418. fsensor_oq_er_max = fsensor_err_cnt;
  419. fsensor_oq_sh_sum += pat9125_s;
  420. }
  421. }
  422. }
  423. else //negative movement
  424. {
  425. }
  426. }
  427. else
  428. { //no movement
  429. }
  430. #ifdef DEBUG_FSENSOR_LOG
  431. if (fsensor_log)
  432. {
  433. printf_P(_N("FSENSOR cnt=%d dy=%d err=%hhu %S\n"), st_cnt, pat9125_y, fsensor_err_cnt, (fsensor_err_cnt > old_err_cnt)?_N("NG!"):_N("OK"));
  434. if (fsensor_oq_meassure) printf_P(_N("FSENSOR st_sum=%u yd_sum=%u er_sum=%u er_max=%hhu yd_max=%u\n"), fsensor_oq_st_sum, fsensor_oq_yd_sum, fsensor_oq_er_sum, fsensor_oq_er_max, fsensor_oq_yd_max);
  435. }
  436. #endif //DEBUG_FSENSOR_LOG
  437. fsensor_dy_old = pat9125_y;
  438. pat9125_y = 0;
  439. _lock = false;
  440. return;
  441. }
  442. void fsensor_setup_interrupt(void)
  443. {
  444. pinMode(FSENSOR_INT_PIN, OUTPUT);
  445. digitalWrite(FSENSOR_INT_PIN, LOW);
  446. fsensor_int_pin_old = 0;
  447. //pciSetup(FSENSOR_INT_PIN);
  448. // !!! "pciSetup()" does not provide the correct results for some MCU pins
  449. // so interrupt registers settings:
  450. FSENSOR_INT_PIN_PCMSK_REG |= bit(FSENSOR_INT_PIN_PCMSK_BIT); // enable corresponding PinChangeInterrupt (individual pin)
  451. PCIFR |= bit(FSENSOR_INT_PIN_PCICR_BIT); // clear previous occasional interrupt (set of pins)
  452. PCICR |= bit(FSENSOR_INT_PIN_PCICR_BIT); // enable corresponding PinChangeInterrupt (set of pins)
  453. }
  454. #endif //PAT9125
  455. void fsensor_st_block_begin(block_t* bl)
  456. {
  457. if (!fsensor_enabled) return;
  458. if (((fsensor_st_cnt > 0) && (bl->direction_bits & 0x8)) ||
  459. ((fsensor_st_cnt < 0) && !(bl->direction_bits & 0x8)))
  460. {
  461. // !!! bit toggling (PINxn <- 1) (for PinChangeInterrupt) does not work for some MCU pins
  462. if (PIN_GET(FSENSOR_INT_PIN)) {PIN_VAL(FSENSOR_INT_PIN, LOW);}
  463. else {PIN_VAL(FSENSOR_INT_PIN, HIGH);}
  464. }
  465. }
  466. void fsensor_st_block_chunk(block_t* bl, int cnt)
  467. {
  468. if (!fsensor_enabled) return;
  469. fsensor_st_cnt += (bl->direction_bits & 0x8)?-cnt:cnt;
  470. if ((fsensor_st_cnt >= fsensor_chunk_len) || (fsensor_st_cnt <= -fsensor_chunk_len))
  471. {
  472. // !!! bit toggling (PINxn <- 1) (for PinChangeInterrupt) does not work for some MCU pins
  473. if (PIN_GET(FSENSOR_INT_PIN)) {PIN_VAL(FSENSOR_INT_PIN, LOW);}
  474. else {PIN_VAL(FSENSOR_INT_PIN, HIGH);}
  475. }
  476. }
  477. //! Common code for enqueing M600 and supplemental codes into the command queue.
  478. //! Used both for the IR sensor and the PAT9125
  479. void fsensor_enque_M600(){
  480. printf_P(PSTR("fsensor_update - M600\n"));
  481. eeprom_update_byte((uint8_t*)EEPROM_FERROR_COUNT, eeprom_read_byte((uint8_t*)EEPROM_FERROR_COUNT) + 1);
  482. eeprom_update_word((uint16_t*)EEPROM_FERROR_COUNT_TOT, eeprom_read_word((uint16_t*)EEPROM_FERROR_COUNT_TOT) + 1);
  483. enquecommand_front_P(PSTR("PRUSA fsensor_recover"));
  484. fsensor_m600_enqueued = true;
  485. enquecommand_front_P((PSTR("M600")));
  486. }
  487. //! @brief filament sensor update (perform M600 on filament runout)
  488. //!
  489. //! Works only if filament sensor is enabled.
  490. //! When the filament sensor error count is larger then FSENSOR_ERR_MAX, pauses print, tries to move filament back and forth.
  491. //! If there is still no plausible signal from filament sensor plans M600 (Filament change).
  492. void fsensor_update(void)
  493. {
  494. #ifdef PAT9125
  495. if (fsensor_enabled && fsensor_watch_runout && (fsensor_err_cnt > FSENSOR_ERR_MAX) && ( ! fsensor_m600_enqueued) )
  496. {
  497. bool autoload_enabled_tmp = fsensor_autoload_enabled;
  498. fsensor_autoload_enabled = false;
  499. bool oq_meassure_enabled_tmp = fsensor_oq_meassure_enabled;
  500. fsensor_oq_meassure_enabled = true;
  501. fsensor_stop_and_save_print();
  502. fsensor_err_cnt = 0;
  503. fsensor_oq_meassure_start(0);
  504. enquecommand_front_P((PSTR("G1 E-3 F200")));
  505. process_commands();
  506. KEEPALIVE_STATE(IN_HANDLER);
  507. cmdqueue_pop_front();
  508. st_synchronize();
  509. enquecommand_front_P((PSTR("G1 E3 F200")));
  510. process_commands();
  511. KEEPALIVE_STATE(IN_HANDLER);
  512. cmdqueue_pop_front();
  513. st_synchronize();
  514. uint8_t err_cnt = fsensor_err_cnt;
  515. fsensor_oq_meassure_stop();
  516. bool err = false;
  517. err |= (err_cnt > 1);
  518. err |= (fsensor_oq_er_sum > 2);
  519. err |= (fsensor_oq_yd_sum < (4 * FSENSOR_OQ_MIN_YD));
  520. if (!err)
  521. {
  522. printf_P(PSTR("fsensor_err_cnt = 0\n"));
  523. fsensor_restore_print_and_continue();
  524. }
  525. else
  526. {
  527. fsensor_enque_M600();
  528. fsensor_watch_runout = false;
  529. }
  530. fsensor_autoload_enabled = autoload_enabled_tmp;
  531. fsensor_oq_meassure_enabled = oq_meassure_enabled_tmp;
  532. }
  533. #else //PAT9125
  534. if ((digitalRead(IR_SENSOR_PIN) == 1) && CHECK_FSENSOR && fsensor_enabled && ir_sensor_detected && ( ! fsensor_m600_enqueued) )
  535. {
  536. fsensor_stop_and_save_print();
  537. fsensor_enque_M600();
  538. }
  539. #endif //PAT9125
  540. }