fsensor.cpp 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789
  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. #ifdef IR_SENSOR_ANALOG
  148. const char* FsensorIRVersionText()
  149. {
  150. switch(oFsensorPCB)
  151. {
  152. case ClFsensorPCB::_Old:
  153. return _T(MSG_IR_03_OR_OLDER);
  154. case ClFsensorPCB::_Rev04:
  155. return _T(MSG_IR_04_OR_NEWER);
  156. default:
  157. return _T(MSG_IR_UNKNOWN);
  158. }
  159. }
  160. #endif //IR_SENSOR_ANALOG
  161. void fsensor_init(void)
  162. {
  163. #ifdef PAT9125
  164. uint8_t pat9125 = pat9125_init();
  165. printf_P(PSTR("PAT9125_init:%hhu\n"), pat9125);
  166. #endif //PAT9125
  167. uint8_t fsensor_enabled = eeprom_read_byte((uint8_t*)EEPROM_FSENSOR);
  168. fsensor_autoload_enabled=eeprom_read_byte((uint8_t*)EEPROM_FSENS_AUTOLOAD_ENABLED);
  169. fsensor_not_responding = false;
  170. #ifdef PAT9125
  171. uint8_t oq_meassure_enabled = eeprom_read_byte((uint8_t*)EEPROM_FSENS_OQ_MEASS_ENABLED);
  172. fsensor_oq_meassure_enabled = (oq_meassure_enabled == 1)?true:false;
  173. fsensor_set_axis_steps_per_unit(cs.axis_steps_per_unit[E_AXIS]);
  174. if (!pat9125){
  175. fsensor_enabled = 0; //disable sensor
  176. fsensor_not_responding = true;
  177. }
  178. #endif //PAT9125
  179. #ifdef IR_SENSOR_ANALOG
  180. bIRsensorStateFlag=false;
  181. oFsensorPCB = (ClFsensorPCB)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_PCB);
  182. oFsensorActionNA = (ClFsensorActionNA)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_ACTION_NA);
  183. // If the fsensor is not responding even at the start of the printer,
  184. // set this flag accordingly to show N/A in Settings->Filament sensor.
  185. // This is even valid for both fsensor board revisions (0.3 or older and 0.4).
  186. // Must be done after reading what type of fsensor board we have
  187. fsensor_not_responding = ! fsensor_IR_check();
  188. #endif //IR_SENSOR_ANALOG
  189. if (fsensor_enabled){
  190. fsensor_enable(false); // (in this case) EEPROM update is not necessary
  191. } else {
  192. fsensor_disable(false); // (in this case) EEPROM update is not necessary
  193. }
  194. printf_P(PSTR("FSensor %S"), (fsensor_enabled?PSTR("ENABLED"):PSTR("DISABLED")));
  195. #ifdef IR_SENSOR_ANALOG
  196. printf_P(PSTR(" (sensor board revision:%S)\n"), FsensorIRVersionText());
  197. #else //IR_SENSOR_ANALOG
  198. MYSERIAL.println();
  199. #endif //IR_SENSOR_ANALOG
  200. if (check_for_ir_sensor()){
  201. ir_sensor_detected = true;
  202. }
  203. }
  204. bool fsensor_enable(bool bUpdateEEPROM)
  205. {
  206. #ifdef PAT9125
  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\n"));
  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\n"));
  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 (digitalRead(IR_SENSOR_PIN) == 1) {
  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. printf_P(PSTR("fsensor_oq_meassure_start\n"));
  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. printf_P(_N("fsensor_oq_result\n"));
  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. pinMode(FSENSOR_INT_PIN, OUTPUT);
  537. digitalWrite(FSENSOR_INT_PIN, LOW);
  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. if (PIN_GET(FSENSOR_INT_PIN)) {PIN_VAL(FSENSOR_INT_PIN, LOW);}
  552. else {PIN_VAL(FSENSOR_INT_PIN, HIGH);}
  553. }
  554. #endif //PAT9125
  555. //! Common code for enqueing M600 and supplemental codes into the command queue.
  556. //! Used both for the IR sensor and the PAT9125
  557. void fsensor_enque_M600(){
  558. printf_P(PSTR("fsensor_update - M600\n"));
  559. eeprom_update_byte((uint8_t*)EEPROM_FERROR_COUNT, eeprom_read_byte((uint8_t*)EEPROM_FERROR_COUNT) + 1);
  560. eeprom_update_word((uint16_t*)EEPROM_FERROR_COUNT_TOT, eeprom_read_word((uint16_t*)EEPROM_FERROR_COUNT_TOT) + 1);
  561. enquecommand_front_P((PSTR("M600")));
  562. }
  563. //! @brief filament sensor update (perform M600 on filament runout)
  564. //!
  565. //! Works only if filament sensor is enabled.
  566. //! When the filament sensor error count is larger then FSENSOR_ERR_MAX, pauses print, tries to move filament back and forth.
  567. //! If there is still no plausible signal from filament sensor plans M600 (Filament change).
  568. void fsensor_update(void)
  569. {
  570. #ifdef PAT9125
  571. if (fsensor_watch_runout && (fsensor_err_cnt > FSENSOR_ERR_MAX))
  572. {
  573. fsensor_stop_and_save_print();
  574. KEEPALIVE_STATE(IN_HANDLER);
  575. bool autoload_enabled_tmp = fsensor_autoload_enabled;
  576. fsensor_autoload_enabled = false;
  577. bool oq_meassure_enabled_tmp = fsensor_oq_meassure_enabled;
  578. fsensor_oq_meassure_enabled = true;
  579. // move the nozzle away while checking the filament
  580. current_position[Z_AXIS] += 0.8;
  581. if(current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS;
  582. plan_buffer_line_curposXYZE(max_feedrate[Z_AXIS]);
  583. st_synchronize();
  584. // check the filament in isolation
  585. fsensor_reset_err_cnt();
  586. fsensor_oq_meassure_start(0);
  587. float e_tmp = current_position[E_AXIS];
  588. current_position[E_AXIS] -= 3;
  589. plan_buffer_line_curposXYZE(250/60);
  590. current_position[E_AXIS] = e_tmp;
  591. plan_buffer_line_curposXYZE(200/60);
  592. st_synchronize();
  593. fsensor_oq_meassure_stop();
  594. bool err = false;
  595. err |= (fsensor_err_cnt > 0); // final error count is non-zero
  596. err |= (fsensor_oq_er_sum > FSENSOR_OQ_MAX_ES); // total error count is above limit
  597. err |= (fsensor_oq_yd_sum < FSENSOR_OQ_MIN_YD); // total measured distance is below limit
  598. fsensor_restore_print_and_continue();
  599. fsensor_autoload_enabled = autoload_enabled_tmp;
  600. fsensor_oq_meassure_enabled = oq_meassure_enabled_tmp;
  601. unsigned long now = _millis();
  602. if (!err && (now - fsensor_softfail_last) > FSENSOR_SOFTERR_DELTA)
  603. fsensor_softfail_ccnt = 0;
  604. if (!err && fsensor_softfail_ccnt <= FSENSOR_SOFTERR_CMAX)
  605. {
  606. printf_P(PSTR("fsensor_err_cnt = 0\n"));
  607. ++fsensor_softfail;
  608. ++fsensor_softfail_ccnt;
  609. fsensor_softfail_last = now;
  610. }
  611. else
  612. {
  613. fsensor_softfail_ccnt = 0;
  614. fsensor_softfail_last = 0;
  615. fsensor_enque_M600();
  616. }
  617. }
  618. #else //PAT9125
  619. if (CHECK_FSENSOR && ir_sensor_detected)
  620. {
  621. if(digitalRead(IR_SENSOR_PIN))
  622. { // IR_SENSOR_PIN ~ H
  623. #ifdef IR_SENSOR_ANALOG
  624. if(!bIRsensorStateFlag)
  625. {
  626. bIRsensorStateFlag=true;
  627. nIRsensorLastTime=_millis();
  628. }
  629. else
  630. {
  631. if((_millis()-nIRsensorLastTime)>IR_SENSOR_STEADY)
  632. {
  633. uint8_t nMUX1,nMUX2;
  634. uint16_t nADC;
  635. bIRsensorStateFlag=false;
  636. // sequence for direct data reading from AD converter
  637. DISABLE_TEMPERATURE_INTERRUPT();
  638. nMUX1=ADMUX; // ADMUX saving
  639. nMUX2=ADCSRB;
  640. adc_setmux(VOLT_IR_PIN);
  641. ADCSRA|=(1<<ADSC); // first conversion after ADMUX change discarded (preventively)
  642. while(ADCSRA&(1<<ADSC))
  643. ;
  644. ADCSRA|=(1<<ADSC); // second conversion used
  645. while(ADCSRA&(1<<ADSC))
  646. ;
  647. nADC=ADC;
  648. ADMUX=nMUX1; // ADMUX restoring
  649. ADCSRB=nMUX2;
  650. ENABLE_TEMPERATURE_INTERRUPT();
  651. // end of sequence for ...
  652. // Detection of correct function of fsensor v04 - it must NOT read >4.6V
  653. // If it does, it means a disconnected cables or faulty board
  654. if( (oFsensorPCB == ClFsensorPCB::_Rev04) && ( (nADC*OVERSAMPLENR) > IRsensor_Hopen_TRESHOLD ) )
  655. {
  656. fsensor_disable();
  657. fsensor_not_responding = true;
  658. printf_P(PSTR("IR sensor not responding (%d)!\n"),1);
  659. if((ClFsensorActionNA)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_ACTION_NA)==ClFsensorActionNA::_Pause)
  660. // if we are printing and FS action is set to "Pause", force pause the print
  661. if(oFsensorActionNA==ClFsensorActionNA::_Pause)
  662. lcd_pause_print();
  663. }
  664. else
  665. {
  666. #endif //IR_SENSOR_ANALOG
  667. fsensor_checkpoint_print();
  668. fsensor_enque_M600();
  669. #ifdef IR_SENSOR_ANALOG
  670. }
  671. }
  672. }
  673. }
  674. else
  675. { // IR_SENSOR_PIN ~ L
  676. bIRsensorStateFlag=false;
  677. #endif //IR_SENSOR_ANALOG
  678. }
  679. }
  680. #endif //PAT9125
  681. }
  682. #ifdef IR_SENSOR_ANALOG
  683. /// This is called only upon start of the printer or when switching the fsensor ON in the menu
  684. /// We cannot do temporal window checks here (aka the voltage has been in some range for a period of time)
  685. bool fsensor_IR_check(){
  686. if( IRsensor_Lmax_TRESHOLD <= current_voltage_raw_IR && current_voltage_raw_IR <= IRsensor_Hmin_TRESHOLD ){
  687. /// If the voltage is in forbidden range, the fsensor is ok, but the lever is mounted improperly.
  688. /// Or the user is so creative so that he can hold a piece of fillament in the hole in such a genius way,
  689. /// that the IR fsensor reading is within 1.5 and 3V ... this would have been highly unusual
  690. /// and would have been considered more like a sabotage than normal printer operation
  691. printf_P(PSTR("fsensor in forbidden range 1.5-3V - check sensor\n"));
  692. return false;
  693. }
  694. if( oFsensorPCB == ClFsensorPCB::_Rev04 ){
  695. /// newer IR sensor cannot normally produce 4.6-5V, this is considered a failure/bad mount
  696. if( IRsensor_Hopen_TRESHOLD <= current_voltage_raw_IR && current_voltage_raw_IR <= IRsensor_VMax_TRESHOLD ){
  697. printf_P(PSTR("fsensor v0.4 in fault range 4.6-5V - unconnected\n"));
  698. return false;
  699. }
  700. /// newer IR sensor cannot normally produce 0-0.3V, this is considered a failure
  701. #if 0 //Disabled as it has to be decided if we gonna use this or not.
  702. if( IRsensor_Hopen_TRESHOLD <= current_voltage_raw_IR && current_voltage_raw_IR <= IRsensor_VMax_TRESHOLD ){
  703. printf_P(PSTR("fsensor v0.4 in fault range 0.0-0.3V - wrong IR sensor\n"));
  704. return false;
  705. }
  706. #endif
  707. }
  708. /// If IR sensor is "uknown state" and filament is not loaded > 1.5V return false
  709. #if 0
  710. if( (oFsensorPCB == ClFsensorPCB::_Undef) && ( current_voltage_raw_IR > IRsensor_Lmax_TRESHOLD ) ){
  711. printf_P(PSTR("Unknown IR sensor version and no filament loaded detected.\n"));
  712. return false;
  713. }
  714. #endif
  715. // otherwise the IR fsensor is considered working correctly
  716. return true;
  717. }
  718. #endif //IR_SENSOR_ANALOG