fsensor.cpp 27 KB

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