fsensor.cpp 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518
  1. #include "Marlin.h"
  2. #include "fsensor.h"
  3. #include <avr/pgmspace.h>
  4. #include "pat9125.h"
  5. #include "stepper.h"
  6. #include "planner.h"
  7. #include "fastio.h"
  8. #include "cmdqueue.h"
  9. //Basic params
  10. #define FSENSOR_CHUNK_LEN 0.64F //filament sensor chunk length 0.64mm
  11. #define FSENSOR_ERR_MAX 17 //filament sensor maximum error count for runout detection
  12. //Optical quality meassurement params
  13. #define FSENSOR_OQ_MAX_ES 6 //maximum error sum while loading (length ~64mm = 100chunks)
  14. #define FSENSOR_OQ_MAX_EM 2 //maximum error counter value while loading
  15. #define FSENSOR_OQ_MIN_YD 2 //minimum yd per chunk (applied to avg value)
  16. #define FSENSOR_OQ_MAX_YD 200 //maximum yd per chunk (applied to avg value)
  17. #define FSENSOR_OQ_MAX_PD 4 //maximum positive deviation (= yd_max/yd_avg)
  18. #define FSENSOR_OQ_MAX_ND 5 //maximum negative deviation (= yd_avg/yd_min)
  19. #define FSENSOR_OQ_MAX_SH 13 //maximum shutter value
  20. const char ERRMSG_PAT9125_NOT_RESP[] PROGMEM = "PAT9125 not responding (%d)!\n";
  21. #define FSENSOR_INT_PIN 63 //filament sensor interrupt pin PK1
  22. #define FSENSOR_INT_PIN_MSK 0x02 //filament sensor interrupt pin mask (bit1)
  23. extern void stop_and_save_print_to_ram(float z_move, float e_move);
  24. extern void restore_print_from_ram_and_continue(float e_move);
  25. extern int8_t FSensorStateMenu;
  26. //uint8_t fsensor_int_pin = FSENSOR_INT_PIN;
  27. uint8_t fsensor_int_pin_old = 0;
  28. int16_t fsensor_chunk_len = 0;
  29. //enabled = initialized and sampled every chunk event
  30. bool fsensor_enabled = true;
  31. //runout watching is done in fsensor_update (called from main loop)
  32. bool fsensor_watch_runout = true;
  33. //not responding - is set if any communication error occured durring initialization or readout
  34. bool fsensor_not_responding = false;
  35. //enable/disable quality meassurement
  36. bool fsensor_oq_meassure_enabled = false;
  37. //number of errors, updated in ISR
  38. uint8_t fsensor_err_cnt = 0;
  39. //variable for accumolating step count (updated callbacks from stepper and ISR)
  40. int16_t fsensor_st_cnt = 0;
  41. //last dy value from pat9125 sensor (used in ISR)
  42. int16_t fsensor_dy_old = 0;
  43. //log flag: 0=log disabled, 1=log enabled
  44. uint8_t fsensor_log = 1;
  45. ////////////////////////////////////////////////////////////////////////////////
  46. //filament autoload variables
  47. //autoload feature enabled
  48. bool fsensor_autoload_enabled = true;
  49. //autoload watching enable/disable flag
  50. bool fsensor_watch_autoload = false;
  51. //
  52. uint16_t fsensor_autoload_y;
  53. //
  54. uint8_t fsensor_autoload_c;
  55. //
  56. uint32_t fsensor_autoload_last_millis;
  57. //
  58. uint8_t fsensor_autoload_sum;
  59. ////////////////////////////////////////////////////////////////////////////////
  60. //filament optical quality meassurement variables
  61. //meassurement enable/disable flag
  62. bool fsensor_oq_meassure = false;
  63. //skip-chunk counter, for accurate meassurement is necesary to skip first chunk...
  64. uint8_t fsensor_oq_skipchunk;
  65. //number of samples from start of meassurement
  66. uint8_t fsensor_oq_samples;
  67. //sum of steps in positive direction movements
  68. uint16_t fsensor_oq_st_sum;
  69. //sum of deltas in positive direction movements
  70. uint16_t fsensor_oq_yd_sum;
  71. //sum of errors durring meassurement
  72. uint16_t fsensor_oq_er_sum;
  73. //max error counter value durring meassurement
  74. uint8_t fsensor_oq_er_max;
  75. //minimum delta value
  76. uint16_t fsensor_oq_yd_min;
  77. //maximum delta value
  78. uint16_t fsensor_oq_yd_max;
  79. //sum of shutter value
  80. uint16_t fsensor_oq_sh_sum;
  81. void fsensor_stop_and_save_print(void)
  82. {
  83. printf_P(PSTR("fsensor_stop_and_save_print\n"));
  84. stop_and_save_print_to_ram(0, 0); //XYZE - no change
  85. }
  86. void fsensor_restore_print_and_continue(void)
  87. {
  88. printf_P(PSTR("fsensor_restore_print_and_continue\n"));
  89. fsensor_watch_runout = true;
  90. fsensor_err_cnt = 0;
  91. restore_print_from_ram_and_continue(0); //XYZ = orig, E - no change
  92. }
  93. void fsensor_init(void)
  94. {
  95. uint8_t pat9125 = pat9125_init();
  96. printf_P(PSTR("PAT9125_init:%hhu\n"), pat9125);
  97. uint8_t fsensor = eeprom_read_byte((uint8_t*)EEPROM_FSENSOR);
  98. fsensor_autoload_enabled=eeprom_read_byte((uint8_t*)EEPROM_FSENS_AUTOLOAD_ENABLED);
  99. uint8_t oq_meassure_enabled = eeprom_read_byte((uint8_t*)EEPROM_FSENS_OQ_MEASS_ENABLED);
  100. fsensor_oq_meassure_enabled = (oq_meassure_enabled == 1)?true:false;
  101. fsensor_chunk_len = (int16_t)(FSENSOR_CHUNK_LEN * axis_steps_per_unit[E_AXIS]);
  102. if (!pat9125)
  103. {
  104. fsensor = 0; //disable sensor
  105. fsensor_not_responding = true;
  106. }
  107. else
  108. fsensor_not_responding = false;
  109. if (fsensor)
  110. fsensor_enable();
  111. else
  112. fsensor_disable();
  113. printf_P(PSTR("FSensor %S\n"), (fsensor_enabled?PSTR("ENABLED"):PSTR("DISABLED\n")));
  114. }
  115. bool fsensor_enable(void)
  116. {
  117. uint8_t pat9125 = pat9125_init();
  118. printf_P(PSTR("PAT9125_init:%hhu\n"), pat9125);
  119. if (pat9125)
  120. fsensor_not_responding = false;
  121. else
  122. fsensor_not_responding = true;
  123. fsensor_enabled = pat9125?true:false;
  124. fsensor_watch_runout = true;
  125. fsensor_oq_meassure = false;
  126. fsensor_err_cnt = 0;
  127. fsensor_dy_old = 0;
  128. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, fsensor_enabled?0x01:0x00);
  129. FSensorStateMenu = fsensor_enabled?1:0;
  130. return fsensor_enabled;
  131. }
  132. void fsensor_disable(void)
  133. {
  134. fsensor_enabled = false;
  135. eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x00);
  136. FSensorStateMenu = 0;
  137. }
  138. void fsensor_autoload_set(bool State)
  139. {
  140. fsensor_autoload_enabled = State;
  141. eeprom_update_byte((unsigned char *)EEPROM_FSENS_AUTOLOAD_ENABLED, fsensor_autoload_enabled);
  142. }
  143. void pciSetup(byte pin)
  144. {
  145. *digitalPinToPCMSK(pin) |= bit (digitalPinToPCMSKbit(pin)); // enable pin
  146. PCIFR |= bit (digitalPinToPCICRbit(pin)); // clear any outstanding interrupt
  147. PCICR |= bit (digitalPinToPCICRbit(pin)); // enable interrupt for the group
  148. }
  149. void fsensor_autoload_check_start(void)
  150. {
  151. // puts_P(_N("fsensor_autoload_check_start\n"));
  152. if (!fsensor_enabled) return;
  153. if (!fsensor_autoload_enabled) return;
  154. if (fsensor_watch_autoload) return;
  155. if (!pat9125_update_y()) //update sensor
  156. {
  157. fsensor_disable();
  158. fsensor_not_responding = true;
  159. fsensor_watch_autoload = false;
  160. printf_P(ERRMSG_PAT9125_NOT_RESP, 3);
  161. return;
  162. }
  163. puts_P(_N("fsensor_autoload_check_start - autoload ENABLED\n"));
  164. fsensor_autoload_y = pat9125_y; //save current y value
  165. fsensor_autoload_c = 0; //reset number of changes counter
  166. fsensor_autoload_sum = 0;
  167. fsensor_autoload_last_millis = millis();
  168. fsensor_watch_runout = false;
  169. fsensor_watch_autoload = true;
  170. fsensor_err_cnt = 0;
  171. }
  172. void fsensor_autoload_check_stop(void)
  173. {
  174. // puts_P(_N("fsensor_autoload_check_stop\n"));
  175. if (!fsensor_enabled) return;
  176. // puts_P(_N("fsensor_autoload_check_stop 1\n"));
  177. if (!fsensor_autoload_enabled) return;
  178. // puts_P(_N("fsensor_autoload_check_stop 2\n"));
  179. if (!fsensor_watch_autoload) return;
  180. puts_P(_N("fsensor_autoload_check_stop - autoload DISABLED\n"));
  181. fsensor_autoload_sum = 0;
  182. fsensor_watch_autoload = false;
  183. fsensor_watch_runout = true;
  184. fsensor_err_cnt = 0;
  185. }
  186. bool fsensor_check_autoload(void)
  187. {
  188. if (!fsensor_enabled) return false;
  189. if (!fsensor_autoload_enabled) return false;
  190. if (!fsensor_watch_autoload)
  191. {
  192. fsensor_autoload_check_start();
  193. return false;
  194. }
  195. uint8_t fsensor_autoload_c_old = fsensor_autoload_c;
  196. if ((millis() - fsensor_autoload_last_millis) < 25) return false;
  197. fsensor_autoload_last_millis = millis();
  198. if (!pat9125_update_y()) //update sensor
  199. {
  200. fsensor_disable();
  201. fsensor_not_responding = true;
  202. printf_P(ERRMSG_PAT9125_NOT_RESP, 2);
  203. return false;
  204. }
  205. int16_t dy = pat9125_y - fsensor_autoload_y;
  206. if (dy) //? dy value is nonzero
  207. {
  208. if (dy > 0) //? delta-y value is positive (inserting)
  209. {
  210. fsensor_autoload_sum += dy;
  211. fsensor_autoload_c += 3; //increment change counter by 3
  212. }
  213. else if (fsensor_autoload_c > 1)
  214. fsensor_autoload_c -= 2; //decrement change counter by 2
  215. fsensor_autoload_y = pat9125_y; //save current value
  216. }
  217. else if (fsensor_autoload_c > 0)
  218. fsensor_autoload_c--;
  219. if (fsensor_autoload_c == 0) fsensor_autoload_sum = 0;
  220. // puts_P(_N("fsensor_check_autoload\n"));
  221. // if (fsensor_autoload_c != fsensor_autoload_c_old)
  222. // printf_P(PSTR("fsensor_check_autoload dy=%d c=%d sum=%d\n"), dy, fsensor_autoload_c, fsensor_autoload_sum);
  223. // if ((fsensor_autoload_c >= 15) && (fsensor_autoload_sum > 30))
  224. if ((fsensor_autoload_c >= 12) && (fsensor_autoload_sum > 20))
  225. {
  226. // puts_P(_N("fsensor_check_autoload = true !!!\n"));
  227. return true;
  228. }
  229. return false;
  230. }
  231. void fsensor_oq_meassure_set(bool State)
  232. {
  233. fsensor_oq_meassure_enabled = State;
  234. eeprom_update_byte((unsigned char *)EEPROM_FSENS_OQ_MEASS_ENABLED, fsensor_oq_meassure_enabled);
  235. }
  236. void fsensor_oq_meassure_start(uint8_t skip)
  237. {
  238. if (!fsensor_enabled) return;
  239. if (!fsensor_oq_meassure_enabled) return;
  240. printf_P(PSTR("fsensor_oq_meassure_start\n"));
  241. fsensor_oq_skipchunk = skip;
  242. fsensor_oq_samples = 0;
  243. fsensor_oq_st_sum = 0;
  244. fsensor_oq_yd_sum = 0;
  245. fsensor_oq_er_sum = 0;
  246. fsensor_oq_er_max = 0;
  247. fsensor_oq_yd_min = FSENSOR_OQ_MAX_YD;
  248. fsensor_oq_yd_max = 0;
  249. fsensor_oq_sh_sum = 0;
  250. pat9125_update();
  251. pat9125_y = 0;
  252. fsensor_watch_runout = false;
  253. fsensor_oq_meassure = true;
  254. }
  255. void fsensor_oq_meassure_stop(void)
  256. {
  257. if (!fsensor_enabled) return;
  258. if (!fsensor_oq_meassure_enabled) return;
  259. printf_P(PSTR("fsensor_oq_meassure_stop, %hhu samples\n"), fsensor_oq_samples);
  260. 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);
  261. 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));
  262. fsensor_oq_meassure = false;
  263. fsensor_watch_runout = true;
  264. fsensor_err_cnt = 0;
  265. }
  266. const char _OK[] PROGMEM = "OK";
  267. const char _NG[] PROGMEM = "NG!";
  268. bool fsensor_oq_result(void)
  269. {
  270. if (!fsensor_enabled) return true;
  271. if (!fsensor_oq_meassure_enabled) return true;
  272. printf_P(_N("fsensor_oq_result\n"));
  273. bool res_er_sum = (fsensor_oq_er_sum <= FSENSOR_OQ_MAX_ES);
  274. printf_P(_N(" er_sum = %u %S\n"), fsensor_oq_er_sum, (res_er_sum?_OK:_NG));
  275. bool res_er_max = (fsensor_oq_er_max <= FSENSOR_OQ_MAX_EM);
  276. printf_P(_N(" er_max = %hhu %S\n"), fsensor_oq_er_max, (res_er_max?_OK:_NG));
  277. uint8_t yd_avg = ((uint32_t)fsensor_oq_yd_sum * fsensor_chunk_len / fsensor_oq_st_sum);
  278. bool res_yd_avg = (yd_avg >= FSENSOR_OQ_MIN_YD) && (yd_avg <= FSENSOR_OQ_MAX_YD);
  279. printf_P(_N(" yd_avg = %hhu %S\n"), yd_avg, (res_yd_avg?_OK:_NG));
  280. bool res_yd_max = (fsensor_oq_yd_max <= (yd_avg * FSENSOR_OQ_MAX_PD));
  281. printf_P(_N(" yd_max = %u %S\n"), fsensor_oq_yd_max, (res_yd_max?_OK:_NG));
  282. bool res_yd_min = (fsensor_oq_yd_min >= (yd_avg / FSENSOR_OQ_MAX_ND));
  283. printf_P(_N(" yd_min = %u %S\n"), fsensor_oq_yd_min, (res_yd_min?_OK:_NG));
  284. uint16_t yd_dev = (fsensor_oq_yd_max - yd_avg) + (yd_avg - fsensor_oq_yd_min);
  285. printf_P(_N(" yd_dev = %u\n"), yd_dev);
  286. uint16_t yd_qua = 10 * yd_avg / (yd_dev + 1);
  287. printf_P(_N(" yd_qua = %u %S\n"), yd_qua, ((yd_qua >= 8)?_OK:_NG));
  288. uint8_t sh_avg = (fsensor_oq_sh_sum / fsensor_oq_samples);
  289. bool res_sh_avg = (sh_avg <= FSENSOR_OQ_MAX_SH);
  290. if (yd_qua >= 8) res_sh_avg = true;
  291. printf_P(_N(" sh_avg = %hhu %S\n"), sh_avg, (res_sh_avg?_OK:_NG));
  292. bool res = res_er_sum && res_er_max && res_yd_avg && res_yd_max && res_yd_min && res_sh_avg;
  293. printf_P(_N("fsensor_oq_result %S\n"), (res?_OK:_NG));
  294. return res;
  295. }
  296. ISR(PCINT2_vect)
  297. {
  298. if (!((fsensor_int_pin_old ^ PINK) & FSENSOR_INT_PIN_MSK)) return;
  299. fsensor_int_pin_old = PINK;
  300. static bool _lock = false;
  301. if (_lock) return;
  302. _lock = true;
  303. int st_cnt = fsensor_st_cnt;
  304. fsensor_st_cnt = 0;
  305. sei();
  306. uint8_t old_err_cnt = fsensor_err_cnt;
  307. uint8_t pat9125_res = fsensor_oq_meassure?pat9125_update():pat9125_update_y();
  308. if (!pat9125_res)
  309. {
  310. fsensor_disable();
  311. fsensor_not_responding = true;
  312. printf_P(ERRMSG_PAT9125_NOT_RESP, 1);
  313. }
  314. if (st_cnt != 0)
  315. { //movement
  316. if (st_cnt > 0) //positive movement
  317. {
  318. if (pat9125_y < 0)
  319. {
  320. if (fsensor_err_cnt)
  321. fsensor_err_cnt += 2;
  322. else
  323. fsensor_err_cnt++;
  324. }
  325. else if (pat9125_y > 0)
  326. {
  327. if (fsensor_err_cnt)
  328. fsensor_err_cnt--;
  329. }
  330. else //(pat9125_y == 0)
  331. if (((fsensor_dy_old <= 0) || (fsensor_err_cnt)) && (st_cnt > (fsensor_chunk_len >> 1)))
  332. fsensor_err_cnt++;
  333. if (fsensor_oq_meassure)
  334. {
  335. if (fsensor_oq_skipchunk)
  336. {
  337. fsensor_oq_skipchunk--;
  338. fsensor_err_cnt = 0;
  339. }
  340. else
  341. {
  342. if (st_cnt == fsensor_chunk_len)
  343. {
  344. if (pat9125_y > 0) if (fsensor_oq_yd_min > pat9125_y) fsensor_oq_yd_min = (fsensor_oq_yd_min + pat9125_y) / 2;
  345. if (pat9125_y >= 0) if (fsensor_oq_yd_max < pat9125_y) fsensor_oq_yd_max = (fsensor_oq_yd_max + pat9125_y) / 2;
  346. }
  347. fsensor_oq_samples++;
  348. fsensor_oq_st_sum += st_cnt;
  349. if (pat9125_y > 0) fsensor_oq_yd_sum += pat9125_y;
  350. if (fsensor_err_cnt > old_err_cnt)
  351. fsensor_oq_er_sum += (fsensor_err_cnt - old_err_cnt);
  352. if (fsensor_oq_er_max < fsensor_err_cnt)
  353. fsensor_oq_er_max = fsensor_err_cnt;
  354. fsensor_oq_sh_sum += pat9125_s;
  355. }
  356. }
  357. }
  358. else //negative movement
  359. {
  360. }
  361. }
  362. else
  363. { //no movement
  364. }
  365. #ifdef DEBUG_FSENSOR_LOG
  366. if (fsensor_log)
  367. {
  368. 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"));
  369. 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);
  370. }
  371. #endif //DEBUG_FSENSOR_LOG
  372. fsensor_dy_old = pat9125_y;
  373. pat9125_y = 0;
  374. _lock = false;
  375. return;
  376. }
  377. void fsensor_st_block_begin(block_t* bl)
  378. {
  379. if (!fsensor_enabled) return;
  380. if (((fsensor_st_cnt > 0) && (bl->direction_bits & 0x8)) ||
  381. ((fsensor_st_cnt < 0) && !(bl->direction_bits & 0x8)))
  382. {
  383. if (_READ(63)) _WRITE(63, LOW);
  384. else _WRITE(63, HIGH);
  385. }
  386. }
  387. void fsensor_st_block_chunk(block_t* bl, int cnt)
  388. {
  389. if (!fsensor_enabled) return;
  390. fsensor_st_cnt += (bl->direction_bits & 0x8)?-cnt:cnt;
  391. if ((fsensor_st_cnt >= fsensor_chunk_len) || (fsensor_st_cnt <= -fsensor_chunk_len))
  392. {
  393. if (_READ(63)) _WRITE(63, LOW);
  394. else _WRITE(63, HIGH);
  395. }
  396. }
  397. void fsensor_update(void)
  398. {
  399. if (fsensor_enabled && fsensor_watch_runout && (fsensor_err_cnt > FSENSOR_ERR_MAX))
  400. {
  401. bool autoload_enabled_tmp = fsensor_autoload_enabled;
  402. fsensor_autoload_enabled = false;
  403. bool oq_meassure_enabled_tmp = fsensor_oq_meassure_enabled;
  404. fsensor_oq_meassure_enabled = true;
  405. fsensor_stop_and_save_print();
  406. fsensor_err_cnt = 0;
  407. fsensor_oq_meassure_start(0);
  408. // st_synchronize();
  409. // for (int axis = X_AXIS; axis <= E_AXIS; axis++)
  410. // current_position[axis] = st_get_position_mm(axis);
  411. /*
  412. current_position[E_AXIS] -= 3;
  413. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 200 / 60, active_extruder);
  414. st_synchronize();
  415. current_position[E_AXIS] += 3;
  416. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], 200 / 60, active_extruder);
  417. st_synchronize();
  418. */
  419. enquecommand_front_P((PSTR("G1 E-3 F200")));
  420. process_commands();
  421. KEEPALIVE_STATE(IN_HANDLER);
  422. cmdqueue_pop_front();
  423. st_synchronize();
  424. enquecommand_front_P((PSTR("G1 E3 F200")));
  425. process_commands();
  426. KEEPALIVE_STATE(IN_HANDLER);
  427. cmdqueue_pop_front();
  428. st_synchronize();
  429. uint8_t err_cnt = fsensor_err_cnt;
  430. fsensor_oq_meassure_stop();
  431. bool err = false;
  432. err |= (err_cnt > 1);
  433. err |= (fsensor_oq_er_sum > 2);
  434. err |= (fsensor_oq_yd_sum < (4 * FSENSOR_OQ_MIN_YD));
  435. if (!err)
  436. {
  437. printf_P(PSTR("fsensor_err_cnt = 0\n"));
  438. fsensor_restore_print_and_continue();
  439. }
  440. else
  441. {
  442. printf_P(PSTR("fsensor_update - M600\n"));
  443. eeprom_update_byte((uint8_t*)EEPROM_FERROR_COUNT, eeprom_read_byte((uint8_t*)EEPROM_FERROR_COUNT) + 1);
  444. eeprom_update_word((uint16_t*)EEPROM_FERROR_COUNT_TOT, eeprom_read_word((uint16_t*)EEPROM_FERROR_COUNT_TOT) + 1);
  445. enquecommand_front_P(PSTR("FSENSOR_RECOVER"));
  446. enquecommand_front_P((PSTR("M600")));
  447. fsensor_watch_runout = false;
  448. }
  449. fsensor_autoload_enabled = autoload_enabled_tmp;
  450. fsensor_oq_meassure_enabled = oq_meassure_enabled_tmp;
  451. }
  452. }
  453. void fsensor_setup_interrupt(void)
  454. {
  455. pinMode(FSENSOR_INT_PIN, OUTPUT);
  456. digitalWrite(FSENSOR_INT_PIN, LOW);
  457. fsensor_int_pin_old = 0;
  458. pciSetup(FSENSOR_INT_PIN);
  459. }