fsensor.cpp 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787
  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. unsigned long nIRsensorLastTime;
  109. #endif //IR_SENSOR_ANALOG
  110. void fsensor_stop_and_save_print(void)
  111. {
  112. printf_P(PSTR("fsensor_stop_and_save_print\n"));
  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. printf_P(PSTR("fsensor_restore_print_and_continue\n"));
  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. printf_P(PSTR("fsensor_checkpoint_print\n"));
  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. if (mmu_enabled == false) { //filament sensor is pat9125, enable only if it is working
  207. uint8_t pat9125 = pat9125_init();
  208. printf_P(PSTR("PAT9125_init:%hhu\n"), pat9125);
  209. if (pat9125)
  210. fsensor_not_responding = false;
  211. else
  212. fsensor_not_responding = true;
  213. fsensor_enabled = pat9125 ? true : false;
  214. fsensor_watch_runout = true;
  215. fsensor_oq_meassure = false;
  216. fsensor_reset_err_cnt();
  217. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, fsensor_enabled ? 0x01 : 0x00);
  218. FSensorStateMenu = fsensor_enabled ? 1 : 0;
  219. }
  220. else //filament sensor is FINDA, always enable
  221. {
  222. fsensor_enabled = true;
  223. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x01);
  224. FSensorStateMenu = 1;
  225. }
  226. #else // PAT9125
  227. #ifdef IR_SENSOR_ANALOG
  228. if(!fsensor_IR_check())
  229. {
  230. bUpdateEEPROM=true;
  231. fsensor_enabled=false;
  232. fsensor_not_responding=true;
  233. FSensorStateMenu=0;
  234. }
  235. else {
  236. #endif //IR_SENSOR_ANALOG
  237. fsensor_enabled=true;
  238. fsensor_not_responding=false;
  239. FSensorStateMenu=1;
  240. #ifdef IR_SENSOR_ANALOG
  241. }
  242. #endif //IR_SENSOR_ANALOG
  243. if(bUpdateEEPROM)
  244. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, FSensorStateMenu);
  245. #endif //PAT9125
  246. return fsensor_enabled;
  247. }
  248. void fsensor_disable(bool bUpdateEEPROM)
  249. {
  250. fsensor_enabled = false;
  251. FSensorStateMenu = 0;
  252. if(bUpdateEEPROM)
  253. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x00);
  254. }
  255. void fsensor_autoload_set(bool State)
  256. {
  257. #ifdef PAT9125
  258. if (!State) fsensor_autoload_check_stop();
  259. #endif //PAT9125
  260. fsensor_autoload_enabled = State;
  261. eeprom_update_byte((unsigned char *)EEPROM_FSENS_AUTOLOAD_ENABLED, fsensor_autoload_enabled);
  262. }
  263. void pciSetup(byte pin)
  264. {
  265. // !!! "digitalPinTo?????bit()" does not provide the correct results for some MCU pins
  266. *digitalPinToPCMSK(pin) |= bit (digitalPinToPCMSKbit(pin)); // enable pin
  267. PCIFR |= bit (digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
  268. PCICR |= bit (digitalPinToPCICRbit(pin)); // enable interrupt for the group
  269. }
  270. #ifdef PAT9125
  271. void fsensor_autoload_check_start(void)
  272. {
  273. // puts_P(_N("fsensor_autoload_check_start\n"));
  274. if (!fsensor_enabled) return;
  275. if (!fsensor_autoload_enabled) return;
  276. if (fsensor_watch_autoload) return;
  277. if (!pat9125_update()) //update sensor
  278. {
  279. fsensor_disable();
  280. fsensor_not_responding = true;
  281. fsensor_watch_autoload = false;
  282. printf_P(ERRMSG_PAT9125_NOT_RESP, 3);
  283. return;
  284. }
  285. puts_P(_N("fsensor_autoload_check_start - autoload ENABLED\n"));
  286. fsensor_autoload_y = pat9125_y; //save current y value
  287. fsensor_autoload_c = 0; //reset number of changes counter
  288. fsensor_autoload_sum = 0;
  289. fsensor_autoload_last_millis = _millis();
  290. fsensor_watch_runout = false;
  291. fsensor_watch_autoload = true;
  292. }
  293. void fsensor_autoload_check_stop(void)
  294. {
  295. // puts_P(_N("fsensor_autoload_check_stop\n"));
  296. if (!fsensor_enabled) return;
  297. // puts_P(_N("fsensor_autoload_check_stop 1\n"));
  298. if (!fsensor_autoload_enabled) return;
  299. // puts_P(_N("fsensor_autoload_check_stop 2\n"));
  300. if (!fsensor_watch_autoload) return;
  301. puts_P(_N("fsensor_autoload_check_stop - autoload DISABLED\n"));
  302. fsensor_autoload_sum = 0;
  303. fsensor_watch_autoload = false;
  304. fsensor_watch_runout = true;
  305. fsensor_reset_err_cnt();
  306. }
  307. #endif //PAT9125
  308. bool fsensor_check_autoload(void)
  309. {
  310. if (!fsensor_enabled) return false;
  311. if (!fsensor_autoload_enabled) return false;
  312. if (ir_sensor_detected) {
  313. if (digitalRead(IR_SENSOR_PIN) == 1) {
  314. fsensor_watch_autoload = true;
  315. }
  316. else if (fsensor_watch_autoload == true) {
  317. fsensor_watch_autoload = false;
  318. return true;
  319. }
  320. }
  321. #ifdef PAT9125
  322. if (!fsensor_watch_autoload)
  323. {
  324. fsensor_autoload_check_start();
  325. return false;
  326. }
  327. #if 0
  328. uint8_t fsensor_autoload_c_old = fsensor_autoload_c;
  329. #endif
  330. if ((_millis() - fsensor_autoload_last_millis) < 25) return false;
  331. fsensor_autoload_last_millis = _millis();
  332. if (!pat9125_update_y()) //update sensor
  333. {
  334. fsensor_disable();
  335. fsensor_not_responding = true;
  336. printf_P(ERRMSG_PAT9125_NOT_RESP, 2);
  337. return false;
  338. }
  339. int16_t dy = pat9125_y - fsensor_autoload_y;
  340. if (dy) //? dy value is nonzero
  341. {
  342. if (dy > 0) //? delta-y value is positive (inserting)
  343. {
  344. fsensor_autoload_sum += dy;
  345. fsensor_autoload_c += 3; //increment change counter by 3
  346. }
  347. else if (fsensor_autoload_c > 1)
  348. fsensor_autoload_c -= 2; //decrement change counter by 2
  349. fsensor_autoload_y = pat9125_y; //save current value
  350. }
  351. else if (fsensor_autoload_c > 0)
  352. fsensor_autoload_c--;
  353. if (fsensor_autoload_c == 0) fsensor_autoload_sum = 0;
  354. #if 0
  355. puts_P(_N("fsensor_check_autoload\n"));
  356. if (fsensor_autoload_c != fsensor_autoload_c_old)
  357. printf_P(PSTR("fsensor_check_autoload dy=%d c=%d sum=%d\n"), dy, fsensor_autoload_c, fsensor_autoload_sum);
  358. #endif
  359. // if ((fsensor_autoload_c >= 15) && (fsensor_autoload_sum > 30))
  360. if ((fsensor_autoload_c >= 12) && (fsensor_autoload_sum > 20))
  361. {
  362. // puts_P(_N("fsensor_check_autoload = true !!!\n"));
  363. return true;
  364. }
  365. #endif //PAT9125
  366. return false;
  367. }
  368. #ifdef PAT9125
  369. void fsensor_oq_meassure_set(bool State)
  370. {
  371. fsensor_oq_meassure_enabled = State;
  372. eeprom_update_byte((unsigned char *)EEPROM_FSENS_OQ_MEASS_ENABLED, fsensor_oq_meassure_enabled);
  373. }
  374. void fsensor_oq_meassure_start(uint8_t skip)
  375. {
  376. if (!fsensor_enabled) return;
  377. if (!fsensor_oq_meassure_enabled) return;
  378. printf_P(PSTR("fsensor_oq_meassure_start\n"));
  379. fsensor_oq_skipchunk = skip;
  380. fsensor_oq_samples = 0;
  381. fsensor_oq_st_sum = 0;
  382. fsensor_oq_yd_sum = 0;
  383. fsensor_oq_er_sum = 0;
  384. fsensor_oq_er_max = 0;
  385. fsensor_oq_yd_min = INT16_MAX;
  386. fsensor_oq_yd_max = 0;
  387. fsensor_oq_sh_sum = 0;
  388. pat9125_update();
  389. pat9125_y = 0;
  390. fsensor_oq_meassure = true;
  391. }
  392. void fsensor_oq_meassure_stop(void)
  393. {
  394. if (!fsensor_enabled) return;
  395. if (!fsensor_oq_meassure_enabled) return;
  396. printf_P(PSTR("fsensor_oq_meassure_stop, %hhu samples\n"), fsensor_oq_samples);
  397. 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);
  398. 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));
  399. fsensor_oq_meassure = false;
  400. }
  401. #ifdef FSENSOR_QUALITY
  402. const char _OK[] PROGMEM = "OK";
  403. const char _NG[] PROGMEM = "NG!";
  404. bool fsensor_oq_result(void)
  405. {
  406. if (!fsensor_enabled) return true;
  407. if (!fsensor_oq_meassure_enabled) return true;
  408. printf_P(_N("fsensor_oq_result\n"));
  409. bool res_er_sum = (fsensor_oq_er_sum <= FSENSOR_OQ_MAX_ES);
  410. printf_P(_N(" er_sum = %u %S\n"), fsensor_oq_er_sum, (res_er_sum?_OK:_NG));
  411. bool res_er_max = (fsensor_oq_er_max <= FSENSOR_OQ_MAX_EM);
  412. printf_P(_N(" er_max = %hhu %S\n"), fsensor_oq_er_max, (res_er_max?_OK:_NG));
  413. uint8_t yd_avg = ((uint32_t)fsensor_oq_yd_sum * fsensor_chunk_len / fsensor_oq_st_sum);
  414. bool res_yd_avg = (yd_avg >= FSENSOR_OQ_MIN_YD) && (yd_avg <= FSENSOR_OQ_MAX_YD);
  415. printf_P(_N(" yd_avg = %hhu %S\n"), yd_avg, (res_yd_avg?_OK:_NG));
  416. bool res_yd_max = (fsensor_oq_yd_max <= (yd_avg * FSENSOR_OQ_MAX_PD));
  417. printf_P(_N(" yd_max = %u %S\n"), fsensor_oq_yd_max, (res_yd_max?_OK:_NG));
  418. bool res_yd_min = (fsensor_oq_yd_min >= (yd_avg / FSENSOR_OQ_MAX_ND));
  419. printf_P(_N(" yd_min = %u %S\n"), fsensor_oq_yd_min, (res_yd_min?_OK:_NG));
  420. uint16_t yd_dev = (fsensor_oq_yd_max - yd_avg) + (yd_avg - fsensor_oq_yd_min);
  421. printf_P(_N(" yd_dev = %u\n"), yd_dev);
  422. uint16_t yd_qua = 10 * yd_avg / (yd_dev + 1);
  423. printf_P(_N(" yd_qua = %u %S\n"), yd_qua, ((yd_qua >= 8)?_OK:_NG));
  424. uint8_t sh_avg = (fsensor_oq_sh_sum / fsensor_oq_samples);
  425. bool res_sh_avg = (sh_avg <= FSENSOR_OQ_MAX_SH);
  426. if (yd_qua >= 8) res_sh_avg = true;
  427. printf_P(_N(" sh_avg = %hhu %S\n"), sh_avg, (res_sh_avg?_OK:_NG));
  428. bool res = res_er_sum && res_er_max && res_yd_avg && res_yd_max && res_yd_min && res_sh_avg;
  429. printf_P(_N("fsensor_oq_result %S\n"), (res?_OK:_NG));
  430. return res;
  431. }
  432. #endif //FSENSOR_QUALITY
  433. FORCE_INLINE static void fsensor_isr(int st_cnt)
  434. {
  435. uint8_t old_err_cnt = fsensor_err_cnt;
  436. uint8_t pat9125_res = fsensor_oq_meassure?pat9125_update():pat9125_update_y();
  437. if (!pat9125_res)
  438. {
  439. fsensor_disable();
  440. fsensor_not_responding = true;
  441. printf_P(ERRMSG_PAT9125_NOT_RESP, 1);
  442. }
  443. if (st_cnt != 0)
  444. {
  445. // movement was planned, check for sensor movement
  446. int8_t st_dir = st_cnt >= 0;
  447. int8_t pat9125_dir = pat9125_y >= 0;
  448. if (pat9125_y == 0)
  449. {
  450. if (st_dir)
  451. {
  452. // no movement detected: we might be within a blind sensor range,
  453. // update the frame and shutter parameters we didn't earlier
  454. if (!fsensor_oq_meassure)
  455. pat9125_update_bs();
  456. // increment the error count only if underexposed: filament likely missing
  457. if ((pat9125_b < FSENSOR_OQ_MIN_BR) && (pat9125_s > FSENSOR_OQ_MAX_SH))
  458. {
  459. // check for a dark frame (<30% avg brightness) with long exposure
  460. ++fsensor_err_cnt;
  461. }
  462. else
  463. {
  464. // good frame, filament likely present
  465. if(fsensor_err_cnt) --fsensor_err_cnt;
  466. }
  467. }
  468. }
  469. else if (pat9125_dir != st_dir)
  470. {
  471. // detected direction opposite of motor movement
  472. if (st_dir) ++fsensor_err_cnt;
  473. }
  474. else if (pat9125_dir == st_dir)
  475. {
  476. // direction agreeing with planned movement
  477. if (fsensor_err_cnt) --fsensor_err_cnt;
  478. }
  479. if (st_dir && fsensor_oq_meassure)
  480. {
  481. // extruding with quality assessment
  482. if (fsensor_oq_skipchunk)
  483. {
  484. fsensor_oq_skipchunk--;
  485. fsensor_err_cnt = 0;
  486. }
  487. else
  488. {
  489. if (st_cnt == fsensor_chunk_len)
  490. {
  491. if (pat9125_y > 0) if (fsensor_oq_yd_min > pat9125_y) fsensor_oq_yd_min = (fsensor_oq_yd_min + pat9125_y) / 2;
  492. if (pat9125_y >= 0) if (fsensor_oq_yd_max < pat9125_y) fsensor_oq_yd_max = (fsensor_oq_yd_max + pat9125_y) / 2;
  493. }
  494. fsensor_oq_samples++;
  495. fsensor_oq_st_sum += st_cnt;
  496. if (pat9125_y > 0) fsensor_oq_yd_sum += pat9125_y;
  497. if (fsensor_err_cnt > old_err_cnt)
  498. fsensor_oq_er_sum += (fsensor_err_cnt - old_err_cnt);
  499. if (fsensor_oq_er_max < fsensor_err_cnt)
  500. fsensor_oq_er_max = fsensor_err_cnt;
  501. fsensor_oq_sh_sum += pat9125_s;
  502. }
  503. }
  504. }
  505. #ifdef DEBUG_FSENSOR_LOG
  506. if (fsensor_log)
  507. {
  508. 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"));
  509. 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);
  510. }
  511. #endif //DEBUG_FSENSOR_LOG
  512. pat9125_y = 0;
  513. }
  514. ISR(FSENSOR_INT_PIN_VECT)
  515. {
  516. if (mmu_enabled || ir_sensor_detected) return;
  517. if (!((fsensor_int_pin_old ^ FSENSOR_INT_PIN_PIN_REG) & FSENSOR_INT_PIN_MASK)) return;
  518. fsensor_int_pin_old = FSENSOR_INT_PIN_PIN_REG;
  519. // prevent isr re-entry
  520. static bool _lock = false;
  521. if (!_lock)
  522. {
  523. // fetch fsensor_st_cnt atomically
  524. int st_cnt = fsensor_st_cnt;
  525. fsensor_st_cnt = 0;
  526. _lock = true;
  527. sei();
  528. fsensor_isr(st_cnt);
  529. cli();
  530. _lock = false;
  531. }
  532. }
  533. void fsensor_setup_interrupt(void)
  534. {
  535. pinMode(FSENSOR_INT_PIN, OUTPUT);
  536. digitalWrite(FSENSOR_INT_PIN, LOW);
  537. fsensor_int_pin_old = 0;
  538. //pciSetup(FSENSOR_INT_PIN);
  539. // !!! "pciSetup()" does not provide the correct results for some MCU pins
  540. // so interrupt registers settings:
  541. FSENSOR_INT_PIN_PCMSK_REG |= bit(FSENSOR_INT_PIN_PCMSK_BIT); // enable corresponding PinChangeInterrupt (individual pin)
  542. PCIFR |= bit(FSENSOR_INT_PIN_PCICR_BIT); // clear previous occasional interrupt (set of pins)
  543. PCICR |= bit(FSENSOR_INT_PIN_PCICR_BIT); // enable corresponding PinChangeInterrupt (set of pins)
  544. }
  545. void fsensor_st_block_chunk(int cnt)
  546. {
  547. if (!fsensor_enabled) return;
  548. fsensor_st_cnt += cnt;
  549. // !!! bit toggling (PINxn <- 1) (for PinChangeInterrupt) does not work for some MCU pins
  550. WRITE(FSENSOR_INT_PIN, !READ(FSENSOR_INT_PIN));
  551. }
  552. #endif //PAT9125
  553. //! Common code for enqueing M600 and supplemental codes into the command queue.
  554. //! Used both for the IR sensor and the PAT9125
  555. void fsensor_enque_M600(){
  556. printf_P(PSTR("fsensor_update - M600\n"));
  557. eeprom_update_byte((uint8_t*)EEPROM_FERROR_COUNT, eeprom_read_byte((uint8_t*)EEPROM_FERROR_COUNT) + 1);
  558. eeprom_update_word((uint16_t*)EEPROM_FERROR_COUNT_TOT, eeprom_read_word((uint16_t*)EEPROM_FERROR_COUNT_TOT) + 1);
  559. enquecommand_front_P((PSTR("M600")));
  560. }
  561. //! @brief filament sensor update (perform M600 on filament runout)
  562. //!
  563. //! Works only if filament sensor is enabled.
  564. //! When the filament sensor error count is larger then FSENSOR_ERR_MAX, pauses print, tries to move filament back and forth.
  565. //! If there is still no plausible signal from filament sensor plans M600 (Filament change).
  566. void fsensor_update(void)
  567. {
  568. #ifdef PAT9125
  569. if (fsensor_watch_runout && (fsensor_err_cnt > FSENSOR_ERR_MAX))
  570. {
  571. fsensor_stop_and_save_print();
  572. KEEPALIVE_STATE(IN_HANDLER);
  573. bool autoload_enabled_tmp = fsensor_autoload_enabled;
  574. fsensor_autoload_enabled = false;
  575. bool oq_meassure_enabled_tmp = fsensor_oq_meassure_enabled;
  576. fsensor_oq_meassure_enabled = true;
  577. // move the nozzle away while checking the filament
  578. current_position[Z_AXIS] += 0.8;
  579. if(current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS;
  580. plan_buffer_line_curposXYZE(max_feedrate[Z_AXIS]);
  581. st_synchronize();
  582. // check the filament in isolation
  583. fsensor_reset_err_cnt();
  584. fsensor_oq_meassure_start(0);
  585. float e_tmp = current_position[E_AXIS];
  586. current_position[E_AXIS] -= 3;
  587. plan_buffer_line_curposXYZE(250/60);
  588. current_position[E_AXIS] = e_tmp;
  589. plan_buffer_line_curposXYZE(200/60);
  590. st_synchronize();
  591. fsensor_oq_meassure_stop();
  592. bool err = false;
  593. err |= (fsensor_err_cnt > 0); // final error count is non-zero
  594. err |= (fsensor_oq_er_sum > FSENSOR_OQ_MAX_ES); // total error count is above limit
  595. err |= (fsensor_oq_yd_sum < FSENSOR_OQ_MIN_YD); // total measured distance is below limit
  596. fsensor_restore_print_and_continue();
  597. fsensor_autoload_enabled = autoload_enabled_tmp;
  598. fsensor_oq_meassure_enabled = oq_meassure_enabled_tmp;
  599. unsigned long now = _millis();
  600. if (!err && (now - fsensor_softfail_last) > FSENSOR_SOFTERR_DELTA)
  601. fsensor_softfail_ccnt = 0;
  602. if (!err && fsensor_softfail_ccnt <= FSENSOR_SOFTERR_CMAX)
  603. {
  604. printf_P(PSTR("fsensor_err_cnt = 0\n"));
  605. ++fsensor_softfail;
  606. ++fsensor_softfail_ccnt;
  607. fsensor_softfail_last = now;
  608. }
  609. else
  610. {
  611. fsensor_softfail_ccnt = 0;
  612. fsensor_softfail_last = 0;
  613. fsensor_enque_M600();
  614. }
  615. }
  616. #else //PAT9125
  617. if (CHECK_FSENSOR && ir_sensor_detected)
  618. {
  619. if(digitalRead(IR_SENSOR_PIN))
  620. { // IR_SENSOR_PIN ~ H
  621. #ifdef IR_SENSOR_ANALOG
  622. if(!bIRsensorStateFlag)
  623. {
  624. bIRsensorStateFlag=true;
  625. nIRsensorLastTime=_millis();
  626. }
  627. else
  628. {
  629. if((_millis()-nIRsensorLastTime)>IR_SENSOR_STEADY)
  630. {
  631. uint8_t nMUX1,nMUX2;
  632. uint16_t nADC;
  633. bIRsensorStateFlag=false;
  634. // sequence for direct data reading from AD converter
  635. DISABLE_TEMPERATURE_INTERRUPT();
  636. nMUX1=ADMUX; // ADMUX saving
  637. nMUX2=ADCSRB;
  638. adc_setmux(VOLT_IR_PIN);
  639. ADCSRA|=(1<<ADSC); // first conversion after ADMUX change discarded (preventively)
  640. while(ADCSRA&(1<<ADSC))
  641. ;
  642. ADCSRA|=(1<<ADSC); // second conversion used
  643. while(ADCSRA&(1<<ADSC))
  644. ;
  645. nADC=ADC;
  646. ADMUX=nMUX1; // ADMUX restoring
  647. ADCSRB=nMUX2;
  648. ENABLE_TEMPERATURE_INTERRUPT();
  649. // end of sequence for ...
  650. // Detection of correct function of fsensor v04 - it must NOT read >4.6V
  651. // If it does, it means a disconnected cables or faulty board
  652. if( (oFsensorPCB == ClFsensorPCB::_Rev04) && ( (nADC*OVERSAMPLENR) > IRsensor_Hopen_TRESHOLD ) )
  653. {
  654. fsensor_disable();
  655. fsensor_not_responding = true;
  656. printf_P(PSTR("IR sensor not responding (%d)!\n"),1);
  657. if((ClFsensorActionNA)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_ACTION_NA)==ClFsensorActionNA::_Pause)
  658. // if we are printing and FS action is set to "Pause", force pause the print
  659. if(oFsensorActionNA==ClFsensorActionNA::_Pause)
  660. lcd_pause_print();
  661. }
  662. else
  663. {
  664. #endif //IR_SENSOR_ANALOG
  665. fsensor_checkpoint_print();
  666. fsensor_enque_M600();
  667. #ifdef IR_SENSOR_ANALOG
  668. }
  669. }
  670. }
  671. }
  672. else
  673. { // IR_SENSOR_PIN ~ L
  674. bIRsensorStateFlag=false;
  675. #endif //IR_SENSOR_ANALOG
  676. }
  677. }
  678. #endif //PAT9125
  679. }
  680. #ifdef IR_SENSOR_ANALOG
  681. /// This is called only upon start of the printer or when switching the fsensor ON in the menu
  682. /// We cannot do temporal window checks here (aka the voltage has been in some range for a period of time)
  683. bool fsensor_IR_check(){
  684. if( IRsensor_Lmax_TRESHOLD <= current_voltage_raw_IR && current_voltage_raw_IR <= IRsensor_Hmin_TRESHOLD ){
  685. /// If the voltage is in forbidden range, the fsensor is ok, but the lever is mounted improperly.
  686. /// Or the user is so creative so that he can hold a piece of fillament in the hole in such a genius way,
  687. /// that the IR fsensor reading is within 1.5 and 3V ... this would have been highly unusual
  688. /// and would have been considered more like a sabotage than normal printer operation
  689. printf_P(PSTR("fsensor in forbidden range 1.5-3V - check sensor\n"));
  690. return false;
  691. }
  692. if( oFsensorPCB == ClFsensorPCB::_Rev04 ){
  693. /// newer IR sensor cannot normally produce 4.6-5V, this is considered a failure/bad mount
  694. if( IRsensor_Hopen_TRESHOLD <= current_voltage_raw_IR && current_voltage_raw_IR <= IRsensor_VMax_TRESHOLD ){
  695. printf_P(PSTR("fsensor v0.4 in fault range 4.6-5V - unconnected\n"));
  696. return false;
  697. }
  698. /// newer IR sensor cannot normally produce 0-0.3V, this is considered a failure
  699. #if 0 //Disabled as it has to be decided if we gonna use this or not.
  700. if( IRsensor_Hopen_TRESHOLD <= current_voltage_raw_IR && current_voltage_raw_IR <= IRsensor_VMax_TRESHOLD ){
  701. printf_P(PSTR("fsensor v0.4 in fault range 0.0-0.3V - wrong IR sensor\n"));
  702. return false;
  703. }
  704. #endif
  705. }
  706. /// If IR sensor is "uknown state" and filament is not loaded > 1.5V return false
  707. #if 0
  708. if( (oFsensorPCB == ClFsensorPCB::_Undef) && ( current_voltage_raw_IR > IRsensor_Lmax_TRESHOLD ) ){
  709. printf_P(PSTR("Unknown IR sensor version and no filament loaded detected.\n"));
  710. return false;
  711. }
  712. #endif
  713. // otherwise the IR fsensor is considered working correctly
  714. return true;
  715. }
  716. #endif //IR_SENSOR_ANALOG