fsensor.cpp 23 KB

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