//! @file #include "Marlin.h" #include "fsensor.h" #include #include "pat9125.h" #include "stepper.h" #include "cmdqueue.h" #include "ultralcd.h" #include "mmu.h" #include "cardreader.h" #include "adc.h" #include "temperature.h" #include "config.h" #include "Filament_sensor.h" //temporary //! @name Basic parameters //! @{ #define FSENSOR_CHUNK_LEN 1.25 //!< filament sensor chunk length (mm) #define FSENSOR_ERR_MAX 4 //!< filament sensor maximum error/chunk count for runout detection #define FSENSOR_SOFTERR_CMAX 3 //!< number of contiguous soft failures before a triggering a runout #define FSENSOR_SOFTERR_DELTA 30000 //!< maximum interval (ms) to consider soft failures contiguous //! @} //! @name Optical quality measurement parameters //! @{ #define FSENSOR_OQ_MAX_ES 2 //!< maximum sum of error blocks during filament recheck #define FSENSOR_OQ_MIN_YD 2 //!< minimum yd sum during filament check (counts per inch) #define FSENSOR_OQ_MIN_BR 80 //!< minimum brightness value #define FSENSOR_OQ_MAX_SH 10 //!< maximum shutter value //! @} const char ERRMSG_PAT9125_NOT_RESP[] PROGMEM = "PAT9125 not responding (%d)!\n"; //! enabled = initialized and sampled every chunk event bool fsensor_enabled = true; //! runout watching is done in fsensor_update (called from main loop) bool fsensor_watch_runout = true; //! not responding - is set if any communication error occurred during initialization or readout bool fsensor_not_responding = false; #ifdef PAT9125 //! optical checking "chunk lenght" (already in steps) int16_t fsensor_chunk_len = 0; //! number of errors, updated in ISR uint8_t fsensor_err_cnt = 0; //! variable for accumulating step count (updated callbacks from stepper and ISR) int16_t fsensor_st_cnt = 0; //! count of total sensor "soft" failures (filament status checks) uint8_t fsensor_softfail = 0; //! timestamp of last soft failure unsigned long fsensor_softfail_last = 0; //! count of soft failures within the configured time uint8_t fsensor_softfail_ccnt = 0; #endif #ifdef DEBUG_FSENSOR_LOG //! log flag: 0=log disabled, 1=log enabled uint8_t fsensor_log = 1; #endif //DEBUG_FSENSOR_LOG //! @name filament autoload variables //! @{ //! autoload feature enabled bool fsensor_autoload_enabled = true; //! @name filament optical quality measurement variables //! @{ //! Measurement enable/disable flag bool fsensor_oq_meassure = false; //! skip-chunk counter, for accurate measurement is necessary to skip first chunk... uint8_t fsensor_oq_skipchunk; //! number of samples from start of measurement uint8_t fsensor_oq_samples; //! sum of steps in positive direction movements uint16_t fsensor_oq_st_sum; //! sum of deltas in positive direction movements uint16_t fsensor_oq_yd_sum; //! sum of errors during measurement uint16_t fsensor_oq_er_sum; //! max error counter value during measurement uint8_t fsensor_oq_er_max; //! minimum delta value int16_t fsensor_oq_yd_min; //! maximum delta value int16_t fsensor_oq_yd_max; //! sum of shutter value uint16_t fsensor_oq_sh_sum; //! @} #ifdef IR_SENSOR_ANALOG ClFsensorActionNA oFsensorActionNA; bool bIRsensorStateFlag=false; ShortTimer tIRsensorCheckTimer; #endif //IR_SENSOR_ANALOG #ifdef PAT9125 // Reset all internal counters to zero, including stepper callbacks void fsensor_reset_err_cnt() { fsensor_err_cnt = 0; pat9125_y = 0; st_reset_fsensor(); } void fsensor_set_axis_steps_per_unit(float u) { fsensor_chunk_len = (int16_t)(FSENSOR_CHUNK_LEN * u); } #endif // fsensor_checkpoint_print cuts the current print job at the current position, // allowing new instructions to be inserted in the middle void fsensor_checkpoint_print(void) { puts_P(PSTR("fsensor_checkpoint_print")); stop_and_save_print_to_ram(0, 0); restore_print_from_ram_and_continue(0); } #ifdef IR_SENSOR_ANALOG const char* FsensorIRVersionText() { switch(oFsensorPCB) { case ClFsensorPCB::_Old: return _T(MSG_IR_03_OR_OLDER); case ClFsensorPCB::_Rev04: return _T(MSG_IR_04_OR_NEWER); default: return _T(MSG_IR_UNKNOWN); } } #endif //IR_SENSOR_ANALOG void fsensor_init(void) { #ifdef PAT9125 uint8_t pat9125 = pat9125_init(); printf_P(PSTR("PAT9125_init:%u\n"), pat9125); #endif //PAT9125 uint8_t fsensor_enabled = eeprom_read_byte((uint8_t*)EEPROM_FSENSOR); fsensor_autoload_enabled=eeprom_read_byte((uint8_t*)EEPROM_FSENS_AUTOLOAD_ENABLED); fsensor_not_responding = false; #ifdef PAT9125 uint8_t oq_meassure_enabled = eeprom_read_byte((uint8_t*)EEPROM_FSENS_OQ_MEASS_ENABLED); fsensor_oq_meassure_enabled = (oq_meassure_enabled == 1)?true:false; fsensor_set_axis_steps_per_unit(cs.axis_steps_per_unit[E_AXIS]); if (!pat9125){ fsensor_enabled = 0; //disable sensor fsensor_not_responding = true; } #endif //PAT9125 #ifdef IR_SENSOR_ANALOG bIRsensorStateFlag=false; oFsensorPCB = (ClFsensorPCB)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_PCB); oFsensorActionNA = (ClFsensorActionNA)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_ACTION_NA); // If the fsensor is not responding even at the start of the printer, // set this flag accordingly to show N/A in Settings->Filament sensor. // This is even valid for both fsensor board revisions (0.3 or older and 0.4). // Must be done after reading what type of fsensor board we have fsensor_not_responding = ! fsensor_IR_check(); #endif //IR_SENSOR_ANALOG if (fsensor_enabled){ fsensor_enable(false); // (in this case) EEPROM update is not necessary } else { fsensor_disable(false); // (in this case) EEPROM update is not necessary } printf_P(PSTR("FSensor %S"), (fsensor_enabled?PSTR("ENABLED"):PSTR("DISABLED"))); #ifdef IR_SENSOR_ANALOG printf_P(PSTR(" (sensor board revision:%S)\n"), FsensorIRVersionText()); #else //IR_SENSOR_ANALOG MYSERIAL.println(); #endif //IR_SENSOR_ANALOG if (check_for_ir_sensor()){ ir_sensor_detected = true; } } bool fsensor_enable(bool bUpdateEEPROM) { #ifdef PAT9125 (void)bUpdateEEPROM; // silence unused warning in this variant if (mmu_enabled == false) { //filament sensor is pat9125, enable only if it is working uint8_t pat9125 = pat9125_init(); printf_P(PSTR("PAT9125_init:%u\n"), pat9125); if (pat9125) fsensor_not_responding = false; else fsensor_not_responding = true; fsensor_enabled = pat9125 ? true : false; fsensor_watch_runout = true; fsensor_oq_meassure = false; fsensor_reset_err_cnt(); eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, fsensor_enabled ? 0x01 : 0x00); FSensorStateMenu = fsensor_enabled ? 1 : 0; } else //filament sensor is FINDA, always enable { fsensor_enabled = true; eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x01); FSensorStateMenu = 1; } #else // PAT9125 #ifdef IR_SENSOR_ANALOG if(!fsensor.checkVoltage(fsensor.getVoltRaw())) { bUpdateEEPROM=true; fsensor_enabled=false; fsensor_not_responding=true; FSensorStateMenu=0; } else { #endif //IR_SENSOR_ANALOG fsensor_enabled=true; fsensor_not_responding=false; FSensorStateMenu=1; #ifdef IR_SENSOR_ANALOG } #endif //IR_SENSOR_ANALOG if(bUpdateEEPROM) eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, FSensorStateMenu); #endif //PAT9125 return fsensor_enabled; } void fsensor_disable(bool bUpdateEEPROM) { fsensor_enabled = false; FSensorStateMenu = 0; if(bUpdateEEPROM) eeprom_update_byte((uint8_t*)EEPROM_FSENSOR, 0x00); } void fsensor_autoload_set(bool State) { #ifdef PAT9125 if (!State) fsensor_autoload_check_stop(); #endif //PAT9125 fsensor_autoload_enabled = State; eeprom_update_byte((unsigned char *)EEPROM_FSENS_AUTOLOAD_ENABLED, fsensor_autoload_enabled); } void pciSetup(byte pin) { // !!! "digitalPinTo?????bit()" does not provide the correct results for some MCU pins *digitalPinToPCMSK(pin) |= bit (digitalPinToPCMSKbit(pin)); // enable pin PCIFR |= bit (digitalPinToPCICRbit(pin)); // clear any outstanding interrupt PCICR |= bit (digitalPinToPCICRbit(pin)); // enable interrupt for the group } #ifdef PAT9125 void fsensor_autoload_check_start(void) { // puts_P(_N("fsensor_autoload_check_start\n")); if (!fsensor_enabled) return; if (!fsensor_autoload_enabled) return; if (fsensor_watch_autoload) return; if (!pat9125_update()) //update sensor { fsensor_disable(); fsensor_not_responding = true; fsensor_watch_autoload = false; printf_P(ERRMSG_PAT9125_NOT_RESP, 3); return; } puts_P(_N("fsensor_autoload_check_start - autoload ENABLED")); fsensor_autoload_y = pat9125_y; //save current y value fsensor_autoload_c = 0; //reset number of changes counter fsensor_autoload_sum = 0; fsensor_autoload_last_millis = _millis(); fsensor_watch_runout = false; fsensor_watch_autoload = true; } void fsensor_autoload_check_stop(void) { // puts_P(_N("fsensor_autoload_check_stop\n")); if (!fsensor_enabled) return; // puts_P(_N("fsensor_autoload_check_stop 1\n")); if (!fsensor_autoload_enabled) return; // puts_P(_N("fsensor_autoload_check_stop 2\n")); if (!fsensor_watch_autoload) return; puts_P(_N("fsensor_autoload_check_stop - autoload DISABLED")); fsensor_autoload_sum = 0; fsensor_watch_autoload = false; fsensor_watch_runout = true; fsensor_reset_err_cnt(); } #endif //PAT9125 bool fsensor_check_autoload(void) { if (!fsensor_enabled) return false; if (!fsensor_autoload_enabled) return false; if (ir_sensor_detected) { if (READ(IR_SENSOR_PIN)) { fsensor_watch_autoload = true; } else if (fsensor_watch_autoload == true) { fsensor_watch_autoload = false; return true; } } #ifdef PAT9125 if (!fsensor_watch_autoload) { fsensor_autoload_check_start(); return false; } #if 0 uint8_t fsensor_autoload_c_old = fsensor_autoload_c; #endif if ((_millis() - fsensor_autoload_last_millis) < 25) return false; fsensor_autoload_last_millis = _millis(); if (!pat9125_update_y()) //update sensor { fsensor_disable(); fsensor_not_responding = true; printf_P(ERRMSG_PAT9125_NOT_RESP, 2); return false; } int16_t dy = pat9125_y - fsensor_autoload_y; if (dy) //? dy value is nonzero { if (dy > 0) //? delta-y value is positive (inserting) { fsensor_autoload_sum += dy; fsensor_autoload_c += 3; //increment change counter by 3 } else if (fsensor_autoload_c > 1) fsensor_autoload_c -= 2; //decrement change counter by 2 fsensor_autoload_y = pat9125_y; //save current value } else if (fsensor_autoload_c > 0) fsensor_autoload_c--; if (fsensor_autoload_c == 0) fsensor_autoload_sum = 0; #if 0 puts_P(_N("fsensor_check_autoload\n")); if (fsensor_autoload_c != fsensor_autoload_c_old) printf_P(PSTR("fsensor_check_autoload dy=%d c=%d sum=%d\n"), dy, fsensor_autoload_c, fsensor_autoload_sum); #endif // if ((fsensor_autoload_c >= 15) && (fsensor_autoload_sum > 30)) if ((fsensor_autoload_c >= 12) && (fsensor_autoload_sum > 20)) { // puts_P(_N("fsensor_check_autoload = true !!!\n")); return true; } #endif //PAT9125 return false; } #ifdef PAT9125 void fsensor_oq_meassure_set(bool State) { fsensor_oq_meassure_enabled = State; eeprom_update_byte((unsigned char *)EEPROM_FSENS_OQ_MEASS_ENABLED, fsensor_oq_meassure_enabled); } void fsensor_oq_meassure_start(uint8_t skip) { if (!fsensor_enabled) return; if (!fsensor_oq_meassure_enabled) return; puts_P(PSTR("fsensor_oq_meassure_start")); fsensor_oq_skipchunk = skip; fsensor_oq_samples = 0; fsensor_oq_st_sum = 0; fsensor_oq_yd_sum = 0; fsensor_oq_er_sum = 0; fsensor_oq_er_max = 0; fsensor_oq_yd_min = INT16_MAX; fsensor_oq_yd_max = 0; fsensor_oq_sh_sum = 0; pat9125_update(); pat9125_y = 0; fsensor_oq_meassure = true; } void fsensor_oq_meassure_stop(void) { if (!fsensor_enabled) return; if (!fsensor_oq_meassure_enabled) return; printf_P(PSTR("fsensor_oq_meassure_stop, %u samples\n"), fsensor_oq_samples); printf_P(_N(" st_sum=%u yd_sum=%u er_sum=%u er_max=%u\n"), fsensor_oq_st_sum, fsensor_oq_yd_sum, fsensor_oq_er_sum, fsensor_oq_er_max); 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)); fsensor_oq_meassure = false; } #ifdef FSENSOR_QUALITY const char _OK[] PROGMEM = "OK"; const char _NG[] PROGMEM = "NG!"; bool fsensor_oq_result(void) { if (!fsensor_enabled) return true; if (!fsensor_oq_meassure_enabled) return true; puts_P(_N("fsensor_oq_result")); bool res_er_sum = (fsensor_oq_er_sum <= FSENSOR_OQ_MAX_ES); printf_P(_N(" er_sum = %u %S\n"), fsensor_oq_er_sum, (res_er_sum?_OK:_NG)); bool res_er_max = (fsensor_oq_er_max <= FSENSOR_OQ_MAX_EM); printf_P(_N(" er_max = %u %S\n"), fsensor_oq_er_max, (res_er_max?_OK:_NG)); uint8_t yd_avg = ((uint32_t)fsensor_oq_yd_sum * fsensor_chunk_len / fsensor_oq_st_sum); bool res_yd_avg = (yd_avg >= FSENSOR_OQ_MIN_YD) && (yd_avg <= FSENSOR_OQ_MAX_YD); printf_P(_N(" yd_avg = %u %S\n"), yd_avg, (res_yd_avg?_OK:_NG)); bool res_yd_max = (fsensor_oq_yd_max <= (yd_avg * FSENSOR_OQ_MAX_PD)); printf_P(_N(" yd_max = %u %S\n"), fsensor_oq_yd_max, (res_yd_max?_OK:_NG)); bool res_yd_min = (fsensor_oq_yd_min >= (yd_avg / FSENSOR_OQ_MAX_ND)); printf_P(_N(" yd_min = %u %S\n"), fsensor_oq_yd_min, (res_yd_min?_OK:_NG)); uint16_t yd_dev = (fsensor_oq_yd_max - yd_avg) + (yd_avg - fsensor_oq_yd_min); printf_P(_N(" yd_dev = %u\n"), yd_dev); uint16_t yd_qua = 10 * yd_avg / (yd_dev + 1); printf_P(_N(" yd_qua = %u %S\n"), yd_qua, ((yd_qua >= 8)?_OK:_NG)); uint8_t sh_avg = (fsensor_oq_sh_sum / fsensor_oq_samples); bool res_sh_avg = (sh_avg <= FSENSOR_OQ_MAX_SH); if (yd_qua >= 8) res_sh_avg = true; printf_P(_N(" sh_avg = %u %S\n"), sh_avg, (res_sh_avg?_OK:_NG)); bool res = res_er_sum && res_er_max && res_yd_avg && res_yd_max && res_yd_min && res_sh_avg; printf_P(_N("fsensor_oq_result %S\n"), (res?_OK:_NG)); return res; } #endif //FSENSOR_QUALITY FORCE_INLINE static void fsensor_isr(int st_cnt) { uint8_t old_err_cnt = fsensor_err_cnt; uint8_t pat9125_res = fsensor_oq_meassure?pat9125_update():pat9125_update_y(); if (!pat9125_res) { fsensor_disable(); fsensor_not_responding = true; printf_P(ERRMSG_PAT9125_NOT_RESP, 1); } if (st_cnt != 0) { // movement was planned, check for sensor movement int8_t st_dir = st_cnt >= 0; int8_t pat9125_dir = pat9125_y >= 0; if (pat9125_y == 0) { if (st_dir) { // no movement detected: we might be within a blind sensor range, // update the frame and shutter parameters we didn't earlier if (!fsensor_oq_meassure) pat9125_update_bs(); // increment the error count only if underexposed: filament likely missing if ((pat9125_b < FSENSOR_OQ_MIN_BR) && (pat9125_s > FSENSOR_OQ_MAX_SH)) { // check for a dark frame (<30% avg brightness) with long exposure ++fsensor_err_cnt; } else { // good frame, filament likely present if(fsensor_err_cnt) --fsensor_err_cnt; } } } else if (pat9125_dir != st_dir) { // detected direction opposite of motor movement if (st_dir) ++fsensor_err_cnt; } else if (pat9125_dir == st_dir) { // direction agreeing with planned movement if (fsensor_err_cnt) --fsensor_err_cnt; } if (st_dir && fsensor_oq_meassure) { // extruding with quality assessment if (fsensor_oq_skipchunk) { fsensor_oq_skipchunk--; fsensor_err_cnt = 0; } else { if (st_cnt == fsensor_chunk_len) { if (pat9125_y > 0) if (fsensor_oq_yd_min > pat9125_y) fsensor_oq_yd_min = (fsensor_oq_yd_min + pat9125_y) / 2; if (pat9125_y >= 0) if (fsensor_oq_yd_max < pat9125_y) fsensor_oq_yd_max = (fsensor_oq_yd_max + pat9125_y) / 2; } fsensor_oq_samples++; fsensor_oq_st_sum += st_cnt; if (pat9125_y > 0) fsensor_oq_yd_sum += pat9125_y; if (fsensor_err_cnt > old_err_cnt) fsensor_oq_er_sum += (fsensor_err_cnt - old_err_cnt); if (fsensor_oq_er_max < fsensor_err_cnt) fsensor_oq_er_max = fsensor_err_cnt; fsensor_oq_sh_sum += pat9125_s; } } } #ifdef DEBUG_FSENSOR_LOG if (fsensor_log) { printf_P(_N("FSENSOR cnt=%d dy=%d err=%u %S\n"), st_cnt, pat9125_y, fsensor_err_cnt, (fsensor_err_cnt > old_err_cnt)?_N("NG!"):_N("OK")); if (fsensor_oq_meassure) printf_P(_N("FSENSOR st_sum=%u yd_sum=%u er_sum=%u er_max=%u yd_max=%u\n"), fsensor_oq_st_sum, fsensor_oq_yd_sum, fsensor_oq_er_sum, fsensor_oq_er_max, fsensor_oq_yd_max); } #endif //DEBUG_FSENSOR_LOG pat9125_y = 0; } ISR(FSENSOR_INT_PIN_VECT) { if (mmu_enabled || ir_sensor_detected) return; if (!((fsensor_int_pin_old ^ FSENSOR_INT_PIN_PIN_REG) & FSENSOR_INT_PIN_MASK)) return; fsensor_int_pin_old = FSENSOR_INT_PIN_PIN_REG; // prevent isr re-entry static bool _lock = false; if (!_lock) { // fetch fsensor_st_cnt atomically int st_cnt = fsensor_st_cnt; fsensor_st_cnt = 0; _lock = true; sei(); fsensor_isr(st_cnt); cli(); _lock = false; } } void fsensor_setup_interrupt(void) { WRITE(FSENSOR_INT_PIN, 0); SET_OUTPUT(FSENSOR_INT_PIN); fsensor_int_pin_old = 0; //pciSetup(FSENSOR_INT_PIN); // !!! "pciSetup()" does not provide the correct results for some MCU pins // so interrupt registers settings: FSENSOR_INT_PIN_PCMSK_REG |= bit(FSENSOR_INT_PIN_PCMSK_BIT); // enable corresponding PinChangeInterrupt (individual pin) PCIFR |= bit(FSENSOR_INT_PIN_PCICR_BIT); // clear previous occasional interrupt (set of pins) PCICR |= bit(FSENSOR_INT_PIN_PCICR_BIT); // enable corresponding PinChangeInterrupt (set of pins) } void fsensor_st_block_chunk(int cnt) { if (!fsensor_enabled) return; fsensor_st_cnt += cnt; // !!! bit toggling (PINxn <- 1) (for PinChangeInterrupt) does not work for some MCU pins WRITE(FSENSOR_INT_PIN, !READ(FSENSOR_INT_PIN)); } #endif //PAT9125 //! Common code for enqueing M600 and supplemental codes into the command queue. //! Used both for the IR sensor and the PAT9125 void fsensor_enque_M600(){ puts_P(PSTR("fsensor_update - M600")); eeprom_update_byte((uint8_t*)EEPROM_FERROR_COUNT, eeprom_read_byte((uint8_t*)EEPROM_FERROR_COUNT) + 1); eeprom_update_word((uint16_t*)EEPROM_FERROR_COUNT_TOT, eeprom_read_word((uint16_t*)EEPROM_FERROR_COUNT_TOT) + 1); enquecommand_front_P((PSTR("M600"))); } //! @brief filament sensor update (perform M600 on filament runout) //! //! Works only if filament sensor is enabled. //! When the filament sensor error count is larger then FSENSOR_ERR_MAX, pauses print, tries to move filament back and forth. //! If there is still no plausible signal from filament sensor plans M600 (Filament change). void fsensor_update(void) { #ifdef PAT9125 if (fsensor_watch_runout && (fsensor_err_cnt > FSENSOR_ERR_MAX)) { fsensor_stop_and_save_print(); KEEPALIVE_STATE(IN_HANDLER); bool autoload_enabled_tmp = fsensor_autoload_enabled; fsensor_autoload_enabled = false; bool oq_meassure_enabled_tmp = fsensor_oq_meassure_enabled; fsensor_oq_meassure_enabled = true; // move the nozzle away while checking the filament current_position[Z_AXIS] += 0.8; if(current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS; plan_buffer_line_curposXYZE(max_feedrate[Z_AXIS]); st_synchronize(); // check the filament in isolation fsensor_reset_err_cnt(); fsensor_oq_meassure_start(0); float e_tmp = current_position[E_AXIS]; current_position[E_AXIS] -= 3; plan_buffer_line_curposXYZE(250/60); current_position[E_AXIS] = e_tmp; plan_buffer_line_curposXYZE(200/60); st_synchronize(); fsensor_oq_meassure_stop(); bool err = false; err |= (fsensor_err_cnt > 0); // final error count is non-zero err |= (fsensor_oq_er_sum > FSENSOR_OQ_MAX_ES); // total error count is above limit err |= (fsensor_oq_yd_sum < FSENSOR_OQ_MIN_YD); // total measured distance is below limit fsensor_restore_print_and_continue(); fsensor_autoload_enabled = autoload_enabled_tmp; fsensor_oq_meassure_enabled = oq_meassure_enabled_tmp; unsigned long now = _millis(); if (!err && (now - fsensor_softfail_last) > FSENSOR_SOFTERR_DELTA) fsensor_softfail_ccnt = 0; if (!err && fsensor_softfail_ccnt <= FSENSOR_SOFTERR_CMAX) { puts_P(PSTR("fsensor_err_cnt = 0")); ++fsensor_softfail; ++fsensor_softfail_ccnt; fsensor_softfail_last = now; } else { fsensor_softfail_ccnt = 0; fsensor_softfail_last = 0; fsensor_enque_M600(); } } #else //PAT9125 if (CHECK_FSENSOR && ir_sensor_detected) { if (READ(IR_SENSOR_PIN)) { // IR_SENSOR_PIN ~ H fsensor_checkpoint_print(); fsensor_enque_M600(); } } #endif //PAT9125 } #ifdef IR_SENSOR_ANALOG /// This is called only upon start of the printer or when switching the fsensor ON in the menu /// We cannot do temporal window checks here (aka the voltage has been in some range for a period of time) bool fsensor_IR_check(uint16_t raw){ if( IRsensor_Lmax_TRESHOLD <= raw && raw <= IRsensor_Hmin_TRESHOLD ){ /// If the voltage is in forbidden range, the fsensor is ok, but the lever is mounted improperly. /// Or the user is so creative so that he can hold a piece of fillament in the hole in such a genius way, /// that the IR fsensor reading is within 1.5 and 3V ... this would have been highly unusual /// and would have been considered more like a sabotage than normal printer operation puts_P(PSTR("fsensor in forbidden range 1.5-3V - check sensor")); return false; } if( oFsensorPCB == ClFsensorPCB::_Rev04 ){ /// newer IR sensor cannot normally produce 4.6-5V, this is considered a failure/bad mount if( IRsensor_Hopen_TRESHOLD <= raw && raw <= IRsensor_VMax_TRESHOLD ){ puts_P(PSTR("fsensor v0.4 in fault range 4.6-5V - unconnected")); return false; } /// newer IR sensor cannot normally produce 0-0.3V, this is considered a failure #if 0 //Disabled as it has to be decided if we gonna use this or not. if( IRsensor_Hopen_TRESHOLD <= raw && raw <= IRsensor_VMax_TRESHOLD ){ puts_P(PSTR("fsensor v0.4 in fault range 0.0-0.3V - wrong IR sensor")); return false; } #endif } /// If IR sensor is "uknown state" and filament is not loaded > 1.5V return false #if 0 if( (oFsensorPCB == ClFsensorPCB::_Undef) && ( raw > IRsensor_Lmax_TRESHOLD ) ){ puts_P(PSTR("Unknown IR sensor version and no filament loaded detected.")); return false; } #endif // otherwise the IR fsensor is considered working correctly return true; } #endif //IR_SENSOR_ANALOG