fsensor.cpp 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733
  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 "io_atmega2560.h"
  8. #include "cmdqueue.h"
  9. #include "ultralcd.h"
  10. #include "mmu.h"
  11. #include "cardreader.h"
  12. #include "adc.h"
  13. #include "temperature.h"
  14. #include "config.h"
  15. //! @name Basic parameters
  16. //! @{
  17. #define FSENSOR_CHUNK_LEN 1.25 //!< filament sensor chunk length (mm)
  18. #define FSENSOR_ERR_MAX 4 //!< filament sensor maximum error/chunk count for runout detection
  19. #define FSENSOR_SOFTERR_CMAX 3 //!< number of contiguous soft failures before a triggering a runout
  20. #define FSENSOR_SOFTERR_DELTA 30000 //!< maximum interval (ms) to consider soft failures contiguous
  21. //! @}
  22. //! @name Optical quality measurement parameters
  23. //! @{
  24. #define FSENSOR_OQ_MAX_ES 2 //!< maximum sum of error blocks during filament recheck
  25. #define FSENSOR_OQ_MIN_YD 2 //!< minimum yd sum during filament check (counts per inch)
  26. #define FSENSOR_OQ_MIN_BR 80 //!< minimum brightness value
  27. #define FSENSOR_OQ_MAX_SH 10 //!< maximum shutter value
  28. //! @}
  29. const char ERRMSG_PAT9125_NOT_RESP[] PROGMEM = "PAT9125 not responding (%d)!\n";
  30. // PJ7 can not be used (does not have PinChangeInterrupt possibility)
  31. #define FSENSOR_INT_PIN 75 //!< filament sensor interrupt pin PJ4
  32. #define FSENSOR_INT_PIN_MASK 0x10 //!< filament sensor interrupt pin mask (bit4)
  33. #define FSENSOR_INT_PIN_PIN_REG PINJ // PIN register @ PJ4
  34. #define FSENSOR_INT_PIN_VECT PCINT1_vect // PinChange ISR @ PJ4
  35. #define FSENSOR_INT_PIN_PCMSK_REG PCMSK1 // PinChangeMaskRegister @ PJ4
  36. #define FSENSOR_INT_PIN_PCMSK_BIT PCINT13 // PinChange Interrupt / PinChange Enable Mask @ PJ4
  37. #define FSENSOR_INT_PIN_PCICR_BIT PCIE1 // PinChange Interrupt Enable / Flag @ PJ4
  38. //! enabled = initialized and sampled every chunk event
  39. bool fsensor_enabled = true;
  40. //! runout watching is done in fsensor_update (called from main loop)
  41. bool fsensor_watch_runout = true;
  42. //! not responding - is set if any communication error occurred during initialization or readout
  43. bool fsensor_not_responding = false;
  44. #ifdef PAT9125
  45. uint8_t fsensor_int_pin_old = 0;
  46. //! optical checking "chunk lenght" (already in steps)
  47. int16_t fsensor_chunk_len = 0;
  48. //! enable/disable quality meassurement
  49. bool fsensor_oq_meassure_enabled = false;
  50. //! number of errors, updated in ISR
  51. uint8_t fsensor_err_cnt = 0;
  52. //! variable for accumulating step count (updated callbacks from stepper and ISR)
  53. int16_t fsensor_st_cnt = 0;
  54. //! count of total sensor "soft" failures (filament status checks)
  55. uint8_t fsensor_softfail = 0;
  56. //! timestamp of last soft failure
  57. unsigned long fsensor_softfail_last = 0;
  58. //! count of soft failures within the configured time
  59. uint8_t fsensor_softfail_ccnt = 0;
  60. #endif
  61. #ifdef DEBUG_FSENSOR_LOG
  62. //! log flag: 0=log disabled, 1=log enabled
  63. uint8_t fsensor_log = 1;
  64. #endif //DEBUG_FSENSOR_LOG
  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. #ifdef PAT9125
  72. //
  73. uint16_t fsensor_autoload_y;
  74. //
  75. uint8_t fsensor_autoload_c;
  76. //
  77. uint32_t fsensor_autoload_last_millis;
  78. //
  79. uint8_t fsensor_autoload_sum;
  80. //! @}
  81. #endif
  82. //! @name filament optical quality measurement variables
  83. //! @{
  84. //! Measurement enable/disable flag
  85. bool fsensor_oq_meassure = false;
  86. //! skip-chunk counter, for accurate measurement is necessary to skip first chunk...
  87. uint8_t fsensor_oq_skipchunk;
  88. //! number of samples from start of measurement
  89. uint8_t fsensor_oq_samples;
  90. //! sum of steps in positive direction movements
  91. uint16_t fsensor_oq_st_sum;
  92. //! sum of deltas in positive direction movements
  93. uint16_t fsensor_oq_yd_sum;
  94. //! sum of errors during measurement
  95. uint16_t fsensor_oq_er_sum;
  96. //! max error counter value during measurement
  97. uint8_t fsensor_oq_er_max;
  98. //! minimum delta value
  99. int16_t fsensor_oq_yd_min;
  100. //! maximum delta value
  101. int16_t fsensor_oq_yd_max;
  102. //! sum of shutter value
  103. uint16_t fsensor_oq_sh_sum;
  104. //! @}
  105. #ifdef IR_SENSOR_ANALOG
  106. ClFsensorPCB oFsensorPCB;
  107. ClFsensorActionNA oFsensorActionNA;
  108. bool bIRsensorStateFlag=false;
  109. unsigned long nIRsensorLastTime;
  110. #endif //IR_SENSOR_ANALOG
  111. void fsensor_stop_and_save_print(void)
  112. {
  113. printf_P(PSTR("fsensor_stop_and_save_print\n"));
  114. stop_and_save_print_to_ram(0, 0);
  115. fsensor_watch_runout = false;
  116. }
  117. #ifdef PAT9125
  118. // Reset all internal counters to zero, including stepper callbacks
  119. void fsensor_reset_err_cnt()
  120. {
  121. fsensor_err_cnt = 0;
  122. pat9125_y = 0;
  123. st_reset_fsensor();
  124. }
  125. void fsensor_set_axis_steps_per_unit(float u)
  126. {
  127. fsensor_chunk_len = (int16_t)(FSENSOR_CHUNK_LEN * u);
  128. }
  129. #endif
  130. void fsensor_restore_print_and_continue(void)
  131. {
  132. printf_P(PSTR("fsensor_restore_print_and_continue\n"));
  133. fsensor_watch_runout = true;
  134. #ifdef PAT9125
  135. fsensor_reset_err_cnt();
  136. #endif
  137. restore_print_from_ram_and_continue(0);
  138. }
  139. // fsensor_checkpoint_print cuts the current print job at the current position,
  140. // allowing new instructions to be inserted in the middle
  141. void fsensor_checkpoint_print(void)
  142. {
  143. printf_P(PSTR("fsensor_checkpoint_print\n"));
  144. stop_and_save_print_to_ram(0, 0);
  145. restore_print_from_ram_and_continue(0);
  146. }
  147. void fsensor_init(void)
  148. {
  149. #ifdef PAT9125
  150. uint8_t pat9125 = pat9125_init();
  151. printf_P(PSTR("PAT9125_init:%hhu\n"), pat9125);
  152. #endif //PAT9125
  153. uint8_t fsensor = eeprom_read_byte((uint8_t*)EEPROM_FSENSOR);
  154. fsensor_autoload_enabled=eeprom_read_byte((uint8_t*)EEPROM_FSENS_AUTOLOAD_ENABLED);
  155. fsensor_not_responding = false;
  156. #ifdef PAT9125
  157. uint8_t oq_meassure_enabled = eeprom_read_byte((uint8_t*)EEPROM_FSENS_OQ_MEASS_ENABLED);
  158. fsensor_oq_meassure_enabled = (oq_meassure_enabled == 1)?true:false;
  159. fsensor_set_axis_steps_per_unit(cs.axis_steps_per_unit[E_AXIS]);
  160. if (!pat9125)
  161. {
  162. fsensor = 0; //disable sensor
  163. fsensor_not_responding = true;
  164. }
  165. #endif //PAT9125
  166. #ifdef IR_SENSOR_ANALOG
  167. bIRsensorStateFlag=false;
  168. oFsensorPCB=(ClFsensorPCB)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_PCB);
  169. oFsensorActionNA=(ClFsensorActionNA)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_ACTION_NA);
  170. #endif //IR_SENSOR_ANALOG
  171. if (fsensor)
  172. fsensor_enable(false); // (in this case) EEPROM update is not necessary
  173. else
  174. fsensor_disable(false); // (in this case) EEPROM update is not necessary
  175. printf_P(PSTR("FSensor %S"), (fsensor_enabled?PSTR("ENABLED"):PSTR("DISABLED")));
  176. #ifdef IR_SENSOR_ANALOG
  177. printf_P(PSTR(" (sensor board revision: %S)\n"),(oFsensorPCB==ClFsensorPCB::_Rev03b)?PSTR("03b or newer"):PSTR("03 or older"));
  178. #else //IR_SENSOR_ANALOG
  179. printf_P(PSTR("\n"));
  180. #endif //IR_SENSOR_ANALOG
  181. if (check_for_ir_sensor()) ir_sensor_detected = true;
  182. }
  183. bool fsensor_enable(bool bUpdateEEPROM)
  184. {
  185. #ifdef PAT9125
  186. if (mmu_enabled == false) { //filament sensor is pat9125, enable only if it is working
  187. uint8_t pat9125 = pat9125_init();
  188. printf_P(PSTR("PAT9125_init:%hhu\n"), pat9125);
  189. if (pat9125)
  190. fsensor_not_responding = false;
  191. else
  192. fsensor_not_responding = true;
  193. fsensor_enabled = pat9125 ? true : false;
  194. fsensor_watch_runout = true;
  195. fsensor_oq_meassure = false;
  196. fsensor_reset_err_cnt();
  197. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, fsensor_enabled ? 0x01 : 0x00);
  198. FSensorStateMenu = fsensor_enabled ? 1 : 0;
  199. }
  200. else //filament sensor is FINDA, always enable
  201. {
  202. fsensor_enabled = true;
  203. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x01);
  204. FSensorStateMenu = 1;
  205. }
  206. #else // PAT9125
  207. #ifdef IR_SENSOR_ANALOG
  208. if(!fsensor_IR_check())
  209. {
  210. bUpdateEEPROM=true;
  211. fsensor_enabled=false;
  212. fsensor_not_responding=true;
  213. FSensorStateMenu=0;
  214. }
  215. else {
  216. #endif //IR_SENSOR_ANALOG
  217. fsensor_enabled=true;
  218. fsensor_not_responding=false;
  219. FSensorStateMenu=1;
  220. #ifdef IR_SENSOR_ANALOG
  221. }
  222. #endif //IR_SENSOR_ANALOG
  223. if(bUpdateEEPROM)
  224. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, FSensorStateMenu);
  225. #endif //PAT9125
  226. return fsensor_enabled;
  227. }
  228. void fsensor_disable(bool bUpdateEEPROM)
  229. {
  230. fsensor_enabled = false;
  231. FSensorStateMenu = 0;
  232. if(bUpdateEEPROM)
  233. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x00);
  234. }
  235. void fsensor_autoload_set(bool State)
  236. {
  237. #ifdef PAT9125
  238. if (!State) fsensor_autoload_check_stop();
  239. #endif //PAT9125
  240. fsensor_autoload_enabled = State;
  241. eeprom_update_byte((unsigned char *)EEPROM_FSENS_AUTOLOAD_ENABLED, fsensor_autoload_enabled);
  242. }
  243. void pciSetup(byte pin)
  244. {
  245. // !!! "digitalPinTo?????bit()" does not provide the correct results for some MCU pins
  246. *digitalPinToPCMSK(pin) |= bit (digitalPinToPCMSKbit(pin)); // enable pin
  247. PCIFR |= bit (digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
  248. PCICR |= bit (digitalPinToPCICRbit(pin)); // enable interrupt for the group
  249. }
  250. #ifdef PAT9125
  251. void fsensor_autoload_check_start(void)
  252. {
  253. // puts_P(_N("fsensor_autoload_check_start\n"));
  254. if (!fsensor_enabled) return;
  255. if (!fsensor_autoload_enabled) return;
  256. if (fsensor_watch_autoload) return;
  257. if (!pat9125_update()) //update sensor
  258. {
  259. fsensor_disable();
  260. fsensor_not_responding = true;
  261. fsensor_watch_autoload = false;
  262. printf_P(ERRMSG_PAT9125_NOT_RESP, 3);
  263. return;
  264. }
  265. puts_P(_N("fsensor_autoload_check_start - autoload ENABLED\n"));
  266. fsensor_autoload_y = pat9125_y; //save current y value
  267. fsensor_autoload_c = 0; //reset number of changes counter
  268. fsensor_autoload_sum = 0;
  269. fsensor_autoload_last_millis = _millis();
  270. fsensor_watch_runout = false;
  271. fsensor_watch_autoload = true;
  272. }
  273. void fsensor_autoload_check_stop(void)
  274. {
  275. // puts_P(_N("fsensor_autoload_check_stop\n"));
  276. if (!fsensor_enabled) return;
  277. // puts_P(_N("fsensor_autoload_check_stop 1\n"));
  278. if (!fsensor_autoload_enabled) return;
  279. // puts_P(_N("fsensor_autoload_check_stop 2\n"));
  280. if (!fsensor_watch_autoload) return;
  281. puts_P(_N("fsensor_autoload_check_stop - autoload DISABLED\n"));
  282. fsensor_autoload_sum = 0;
  283. fsensor_watch_autoload = false;
  284. fsensor_watch_runout = true;
  285. fsensor_reset_err_cnt();
  286. }
  287. #endif //PAT9125
  288. bool fsensor_check_autoload(void)
  289. {
  290. if (!fsensor_enabled) return false;
  291. if (!fsensor_autoload_enabled) return false;
  292. if (ir_sensor_detected) {
  293. if (digitalRead(IR_SENSOR_PIN) == 1) {
  294. fsensor_watch_autoload = true;
  295. }
  296. else if (fsensor_watch_autoload == true) {
  297. fsensor_watch_autoload = false;
  298. return true;
  299. }
  300. }
  301. #ifdef PAT9125
  302. if (!fsensor_watch_autoload)
  303. {
  304. fsensor_autoload_check_start();
  305. return false;
  306. }
  307. #if 0
  308. uint8_t fsensor_autoload_c_old = fsensor_autoload_c;
  309. #endif
  310. if ((_millis() - fsensor_autoload_last_millis) < 25) return false;
  311. fsensor_autoload_last_millis = _millis();
  312. if (!pat9125_update_y()) //update sensor
  313. {
  314. fsensor_disable();
  315. fsensor_not_responding = true;
  316. printf_P(ERRMSG_PAT9125_NOT_RESP, 2);
  317. return false;
  318. }
  319. int16_t dy = pat9125_y - fsensor_autoload_y;
  320. if (dy) //? dy value is nonzero
  321. {
  322. if (dy > 0) //? delta-y value is positive (inserting)
  323. {
  324. fsensor_autoload_sum += dy;
  325. fsensor_autoload_c += 3; //increment change counter by 3
  326. }
  327. else if (fsensor_autoload_c > 1)
  328. fsensor_autoload_c -= 2; //decrement change counter by 2
  329. fsensor_autoload_y = pat9125_y; //save current value
  330. }
  331. else if (fsensor_autoload_c > 0)
  332. fsensor_autoload_c--;
  333. if (fsensor_autoload_c == 0) fsensor_autoload_sum = 0;
  334. #if 0
  335. puts_P(_N("fsensor_check_autoload\n"));
  336. if (fsensor_autoload_c != fsensor_autoload_c_old)
  337. printf_P(PSTR("fsensor_check_autoload dy=%d c=%d sum=%d\n"), dy, fsensor_autoload_c, fsensor_autoload_sum);
  338. #endif
  339. // if ((fsensor_autoload_c >= 15) && (fsensor_autoload_sum > 30))
  340. if ((fsensor_autoload_c >= 12) && (fsensor_autoload_sum > 20))
  341. {
  342. // puts_P(_N("fsensor_check_autoload = true !!!\n"));
  343. return true;
  344. }
  345. #endif //PAT9125
  346. return false;
  347. }
  348. #ifdef PAT9125
  349. void fsensor_oq_meassure_set(bool State)
  350. {
  351. fsensor_oq_meassure_enabled = State;
  352. eeprom_update_byte((unsigned char *)EEPROM_FSENS_OQ_MEASS_ENABLED, fsensor_oq_meassure_enabled);
  353. }
  354. void fsensor_oq_meassure_start(uint8_t skip)
  355. {
  356. if (!fsensor_enabled) return;
  357. if (!fsensor_oq_meassure_enabled) return;
  358. printf_P(PSTR("fsensor_oq_meassure_start\n"));
  359. fsensor_oq_skipchunk = skip;
  360. fsensor_oq_samples = 0;
  361. fsensor_oq_st_sum = 0;
  362. fsensor_oq_yd_sum = 0;
  363. fsensor_oq_er_sum = 0;
  364. fsensor_oq_er_max = 0;
  365. fsensor_oq_yd_min = INT16_MAX;
  366. fsensor_oq_yd_max = 0;
  367. fsensor_oq_sh_sum = 0;
  368. pat9125_update();
  369. pat9125_y = 0;
  370. fsensor_oq_meassure = true;
  371. }
  372. void fsensor_oq_meassure_stop(void)
  373. {
  374. if (!fsensor_enabled) return;
  375. if (!fsensor_oq_meassure_enabled) return;
  376. printf_P(PSTR("fsensor_oq_meassure_stop, %hhu samples\n"), fsensor_oq_samples);
  377. 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);
  378. 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));
  379. fsensor_oq_meassure = false;
  380. }
  381. #ifdef FSENSOR_QUALITY
  382. const char _OK[] PROGMEM = "OK";
  383. const char _NG[] PROGMEM = "NG!";
  384. bool fsensor_oq_result(void)
  385. {
  386. if (!fsensor_enabled) return true;
  387. if (!fsensor_oq_meassure_enabled) return true;
  388. printf_P(_N("fsensor_oq_result\n"));
  389. bool res_er_sum = (fsensor_oq_er_sum <= FSENSOR_OQ_MAX_ES);
  390. printf_P(_N(" er_sum = %u %S\n"), fsensor_oq_er_sum, (res_er_sum?_OK:_NG));
  391. bool res_er_max = (fsensor_oq_er_max <= FSENSOR_OQ_MAX_EM);
  392. printf_P(_N(" er_max = %hhu %S\n"), fsensor_oq_er_max, (res_er_max?_OK:_NG));
  393. uint8_t yd_avg = ((uint32_t)fsensor_oq_yd_sum * fsensor_chunk_len / fsensor_oq_st_sum);
  394. bool res_yd_avg = (yd_avg >= FSENSOR_OQ_MIN_YD) && (yd_avg <= FSENSOR_OQ_MAX_YD);
  395. printf_P(_N(" yd_avg = %hhu %S\n"), yd_avg, (res_yd_avg?_OK:_NG));
  396. bool res_yd_max = (fsensor_oq_yd_max <= (yd_avg * FSENSOR_OQ_MAX_PD));
  397. printf_P(_N(" yd_max = %u %S\n"), fsensor_oq_yd_max, (res_yd_max?_OK:_NG));
  398. bool res_yd_min = (fsensor_oq_yd_min >= (yd_avg / FSENSOR_OQ_MAX_ND));
  399. printf_P(_N(" yd_min = %u %S\n"), fsensor_oq_yd_min, (res_yd_min?_OK:_NG));
  400. uint16_t yd_dev = (fsensor_oq_yd_max - yd_avg) + (yd_avg - fsensor_oq_yd_min);
  401. printf_P(_N(" yd_dev = %u\n"), yd_dev);
  402. uint16_t yd_qua = 10 * yd_avg / (yd_dev + 1);
  403. printf_P(_N(" yd_qua = %u %S\n"), yd_qua, ((yd_qua >= 8)?_OK:_NG));
  404. uint8_t sh_avg = (fsensor_oq_sh_sum / fsensor_oq_samples);
  405. bool res_sh_avg = (sh_avg <= FSENSOR_OQ_MAX_SH);
  406. if (yd_qua >= 8) res_sh_avg = true;
  407. printf_P(_N(" sh_avg = %hhu %S\n"), sh_avg, (res_sh_avg?_OK:_NG));
  408. bool res = res_er_sum && res_er_max && res_yd_avg && res_yd_max && res_yd_min && res_sh_avg;
  409. printf_P(_N("fsensor_oq_result %S\n"), (res?_OK:_NG));
  410. return res;
  411. }
  412. #endif //FSENSOR_QUALITY
  413. ISR(FSENSOR_INT_PIN_VECT)
  414. {
  415. if (mmu_enabled || ir_sensor_detected) return;
  416. if (!((fsensor_int_pin_old ^ FSENSOR_INT_PIN_PIN_REG) & FSENSOR_INT_PIN_MASK)) return;
  417. fsensor_int_pin_old = FSENSOR_INT_PIN_PIN_REG;
  418. // prevent isr re-entry
  419. static bool _lock = false;
  420. if (_lock) return;
  421. _lock = true;
  422. // fetch fsensor_st_cnt atomically
  423. int st_cnt = fsensor_st_cnt;
  424. fsensor_st_cnt = 0;
  425. sei();
  426. uint8_t old_err_cnt = fsensor_err_cnt;
  427. uint8_t pat9125_res = fsensor_oq_meassure?pat9125_update():pat9125_update_y();
  428. if (!pat9125_res)
  429. {
  430. fsensor_disable();
  431. fsensor_not_responding = true;
  432. printf_P(ERRMSG_PAT9125_NOT_RESP, 1);
  433. }
  434. if (st_cnt != 0)
  435. {
  436. // movement was planned, check for sensor movement
  437. int8_t st_dir = st_cnt >= 0;
  438. int8_t pat9125_dir = pat9125_y >= 0;
  439. if (pat9125_y == 0)
  440. {
  441. if (st_dir)
  442. {
  443. // no movement detected: we might be within a blind sensor range,
  444. // update the frame and shutter parameters we didn't earlier
  445. if (!fsensor_oq_meassure)
  446. pat9125_update_bs();
  447. // increment the error count only if underexposed: filament likely missing
  448. if ((pat9125_b < FSENSOR_OQ_MIN_BR) && (pat9125_s > FSENSOR_OQ_MAX_SH))
  449. {
  450. // check for a dark frame (<30% avg brightness) with long exposure
  451. ++fsensor_err_cnt;
  452. }
  453. else
  454. {
  455. // good frame, filament likely present
  456. if(fsensor_err_cnt) --fsensor_err_cnt;
  457. }
  458. }
  459. }
  460. else if (pat9125_dir != st_dir)
  461. {
  462. // detected direction opposite of motor movement
  463. if (st_dir) ++fsensor_err_cnt;
  464. }
  465. else if (pat9125_dir == st_dir)
  466. {
  467. // direction agreeing with planned movement
  468. if (fsensor_err_cnt) --fsensor_err_cnt;
  469. }
  470. if (st_dir && fsensor_oq_meassure)
  471. {
  472. // extruding with quality assessment
  473. if (fsensor_oq_skipchunk)
  474. {
  475. fsensor_oq_skipchunk--;
  476. fsensor_err_cnt = 0;
  477. }
  478. else
  479. {
  480. if (st_cnt == fsensor_chunk_len)
  481. {
  482. if (pat9125_y > 0) if (fsensor_oq_yd_min > pat9125_y) fsensor_oq_yd_min = (fsensor_oq_yd_min + pat9125_y) / 2;
  483. if (pat9125_y >= 0) if (fsensor_oq_yd_max < pat9125_y) fsensor_oq_yd_max = (fsensor_oq_yd_max + pat9125_y) / 2;
  484. }
  485. fsensor_oq_samples++;
  486. fsensor_oq_st_sum += st_cnt;
  487. if (pat9125_y > 0) fsensor_oq_yd_sum += pat9125_y;
  488. if (fsensor_err_cnt > old_err_cnt)
  489. fsensor_oq_er_sum += (fsensor_err_cnt - old_err_cnt);
  490. if (fsensor_oq_er_max < fsensor_err_cnt)
  491. fsensor_oq_er_max = fsensor_err_cnt;
  492. fsensor_oq_sh_sum += pat9125_s;
  493. }
  494. }
  495. }
  496. #ifdef DEBUG_FSENSOR_LOG
  497. if (fsensor_log)
  498. {
  499. 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"));
  500. 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);
  501. }
  502. #endif //DEBUG_FSENSOR_LOG
  503. pat9125_y = 0;
  504. _lock = false;
  505. return;
  506. }
  507. void fsensor_setup_interrupt(void)
  508. {
  509. pinMode(FSENSOR_INT_PIN, OUTPUT);
  510. digitalWrite(FSENSOR_INT_PIN, LOW);
  511. fsensor_int_pin_old = 0;
  512. //pciSetup(FSENSOR_INT_PIN);
  513. // !!! "pciSetup()" does not provide the correct results for some MCU pins
  514. // so interrupt registers settings:
  515. FSENSOR_INT_PIN_PCMSK_REG |= bit(FSENSOR_INT_PIN_PCMSK_BIT); // enable corresponding PinChangeInterrupt (individual pin)
  516. PCIFR |= bit(FSENSOR_INT_PIN_PCICR_BIT); // clear previous occasional interrupt (set of pins)
  517. PCICR |= bit(FSENSOR_INT_PIN_PCICR_BIT); // enable corresponding PinChangeInterrupt (set of pins)
  518. }
  519. void fsensor_st_block_chunk(int cnt)
  520. {
  521. if (!fsensor_enabled) return;
  522. fsensor_st_cnt += cnt;
  523. // !!! bit toggling (PINxn <- 1) (for PinChangeInterrupt) does not work for some MCU pins
  524. if (PIN_GET(FSENSOR_INT_PIN)) {PIN_VAL(FSENSOR_INT_PIN, LOW);}
  525. else {PIN_VAL(FSENSOR_INT_PIN, HIGH);}
  526. }
  527. #endif //PAT9125
  528. //! Common code for enqueing M600 and supplemental codes into the command queue.
  529. //! Used both for the IR sensor and the PAT9125
  530. void fsensor_enque_M600(){
  531. printf_P(PSTR("fsensor_update - M600\n"));
  532. eeprom_update_byte((uint8_t*)EEPROM_FERROR_COUNT, eeprom_read_byte((uint8_t*)EEPROM_FERROR_COUNT) + 1);
  533. eeprom_update_word((uint16_t*)EEPROM_FERROR_COUNT_TOT, eeprom_read_word((uint16_t*)EEPROM_FERROR_COUNT_TOT) + 1);
  534. enquecommand_front_P((PSTR("M600")));
  535. }
  536. //! @brief filament sensor update (perform M600 on filament runout)
  537. //!
  538. //! Works only if filament sensor is enabled.
  539. //! When the filament sensor error count is larger then FSENSOR_ERR_MAX, pauses print, tries to move filament back and forth.
  540. //! If there is still no plausible signal from filament sensor plans M600 (Filament change).
  541. void fsensor_update(void)
  542. {
  543. #ifdef PAT9125
  544. if (fsensor_watch_runout && (fsensor_err_cnt > FSENSOR_ERR_MAX))
  545. {
  546. fsensor_stop_and_save_print();
  547. KEEPALIVE_STATE(IN_HANDLER);
  548. bool autoload_enabled_tmp = fsensor_autoload_enabled;
  549. fsensor_autoload_enabled = false;
  550. bool oq_meassure_enabled_tmp = fsensor_oq_meassure_enabled;
  551. fsensor_oq_meassure_enabled = true;
  552. // move the nozzle away while checking the filament
  553. current_position[Z_AXIS] += 0.8;
  554. if(current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS;
  555. plan_buffer_line_curposXYZE(max_feedrate[Z_AXIS], active_extruder);
  556. st_synchronize();
  557. // check the filament in isolation
  558. fsensor_reset_err_cnt();
  559. fsensor_oq_meassure_start(0);
  560. float e_tmp = current_position[E_AXIS];
  561. current_position[E_AXIS] -= 3;
  562. plan_buffer_line_curposXYZE(250/60, active_extruder);
  563. current_position[E_AXIS] = e_tmp;
  564. plan_buffer_line_curposXYZE(200/60, active_extruder);
  565. st_synchronize();
  566. fsensor_oq_meassure_stop();
  567. bool err = false;
  568. err |= (fsensor_err_cnt > 0); // final error count is non-zero
  569. err |= (fsensor_oq_er_sum > FSENSOR_OQ_MAX_ES); // total error count is above limit
  570. err |= (fsensor_oq_yd_sum < FSENSOR_OQ_MIN_YD); // total measured distance is below limit
  571. fsensor_restore_print_and_continue();
  572. fsensor_autoload_enabled = autoload_enabled_tmp;
  573. fsensor_oq_meassure_enabled = oq_meassure_enabled_tmp;
  574. unsigned long now = _millis();
  575. if (!err && (now - fsensor_softfail_last) > FSENSOR_SOFTERR_DELTA)
  576. fsensor_softfail_ccnt = 0;
  577. if (!err && fsensor_softfail_ccnt <= FSENSOR_SOFTERR_CMAX)
  578. {
  579. printf_P(PSTR("fsensor_err_cnt = 0\n"));
  580. ++fsensor_softfail;
  581. ++fsensor_softfail_ccnt;
  582. fsensor_softfail_last = now;
  583. }
  584. else
  585. {
  586. fsensor_softfail_ccnt = 0;
  587. fsensor_softfail_last = 0;
  588. fsensor_enque_M600();
  589. }
  590. }
  591. #else //PAT9125
  592. if (CHECK_FSENSOR && ir_sensor_detected)
  593. {
  594. if(digitalRead(IR_SENSOR_PIN))
  595. { // IR_SENSOR_PIN ~ H
  596. #ifdef IR_SENSOR_ANALOG
  597. if(!bIRsensorStateFlag)
  598. {
  599. bIRsensorStateFlag=true;
  600. nIRsensorLastTime=_millis();
  601. }
  602. else
  603. {
  604. if((_millis()-nIRsensorLastTime)>IR_SENSOR_STEADY)
  605. {
  606. uint8_t nMUX1,nMUX2;
  607. uint16_t nADC;
  608. bIRsensorStateFlag=false;
  609. // sequence for direct data reading from AD converter
  610. DISABLE_TEMPERATURE_INTERRUPT();
  611. nMUX1=ADMUX; // ADMUX saving
  612. nMUX2=ADCSRB;
  613. adc_setmux(VOLT_IR_PIN);
  614. ADCSRA|=(1<<ADSC); // first conversion after ADMUX change discarded (preventively)
  615. while(ADCSRA&(1<<ADSC))
  616. ;
  617. ADCSRA|=(1<<ADSC); // second conversion used
  618. while(ADCSRA&(1<<ADSC))
  619. ;
  620. nADC=ADC;
  621. ADMUX=nMUX1; // ADMUX restoring
  622. ADCSRB=nMUX2;
  623. ENABLE_TEMPERATURE_INTERRUPT();
  624. // end of sequence for ...
  625. if((oFsensorPCB==ClFsensorPCB::_Rev03b)&&((nADC*OVERSAMPLENR)>((int)IRsensor_Hopen_TRESHOLD)))
  626. {
  627. fsensor_disable();
  628. fsensor_not_responding = true;
  629. printf_P(PSTR("IR sensor not responding (%d)!\n"),1);
  630. if((ClFsensorActionNA)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_ACTION_NA)==ClFsensorActionNA::_Pause)
  631. if(oFsensorActionNA==ClFsensorActionNA::_Pause)
  632. lcd_pause_print();
  633. }
  634. else
  635. {
  636. #endif //IR_SENSOR_ANALOG
  637. fsensor_checkpoint_print();
  638. fsensor_enque_M600();
  639. #ifdef IR_SENSOR_ANALOG
  640. }
  641. }
  642. }
  643. }
  644. else
  645. { // IR_SENSOR_PIN ~ L
  646. bIRsensorStateFlag=false;
  647. #endif //IR_SENSOR_ANALOG
  648. }
  649. }
  650. #endif //PAT9125
  651. }
  652. #ifdef IR_SENSOR_ANALOG
  653. bool fsensor_IR_check()
  654. {
  655. uint16_t volt_IR_int;
  656. bool bCheckResult;
  657. volt_IR_int=current_voltage_raw_IR;
  658. bCheckResult=(volt_IR_int<((int)IRsensor_Lmax_TRESHOLD))||(volt_IR_int>((int)IRsensor_Hmin_TRESHOLD));
  659. bCheckResult=bCheckResult&&(!((oFsensorPCB==ClFsensorPCB::_Rev03b)&&(volt_IR_int>((int)IRsensor_Hopen_TRESHOLD))));
  660. return(bCheckResult);
  661. }
  662. #endif //IR_SENSOR_ANALOG