diff --git a/Firmware/fsensor.cpp b/Firmware/fsensor.cpp new file mode 100755 index 000000000..351e9a786 --- /dev/null +++ b/Firmware/fsensor.cpp @@ -0,0 +1,820 @@ +//! @file + +#include "Marlin.h" + +#include "fsensor.h" +#include +#include "pat9125.h" +#include "stepper.h" +#include "cmdqueue.h" +#include "ultralcd.h" +#include "mmu2.h" +#include "cardreader.h" + +#include "adc.h" +#include "temperature.h" +#include "config.h" + +//! @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"; + +// PJ7 can not be used (does not have PinChangeInterrupt possibility) +#define FSENSOR_INT_PIN 75 //!< filament sensor interrupt pin PJ4 +#define FSENSOR_INT_PIN_MASK 0x10 //!< filament sensor interrupt pin mask (bit4) +#define FSENSOR_INT_PIN_PIN_REG PINJ // PIN register @ PJ4 +#define FSENSOR_INT_PIN_VECT PCINT1_vect // PinChange ISR @ PJ4 +#define FSENSOR_INT_PIN_PCMSK_REG PCMSK1 // PinChangeMaskRegister @ PJ4 +#define FSENSOR_INT_PIN_PCMSK_BIT PCINT13 // PinChange Interrupt / PinChange Enable Mask @ PJ4 +#define FSENSOR_INT_PIN_PCICR_BIT PCIE1 // PinChange Interrupt Enable / Flag @ PJ4 + +//! 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; + +/// This flag was originally located in mmu.cpp. Not sure what it was supposed to do, but it looks like +/// it was holding "true" all the time on MK3S. +#ifndef IR_SENSOR +bool ir_sensor_detected = false; +bool check_for_ir_sensor(); ///< detects IR sensor and updates ir_sensor_detected + +bool IRSensorDetected() { + return ir_sensor_detected; +} +#endif + +#ifdef PAT9125 +uint8_t fsensor_int_pin_old = 0; +//! optical checking "chunk lenght" (already in steps) +int16_t fsensor_chunk_len = 0; +//! enable/disable quality meassurement +bool fsensor_oq_meassure_enabled = false; +//! 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; +//! autoload watching enable/disable flag +bool fsensor_watch_autoload = false; + +#ifdef PAT9125 +// +uint16_t fsensor_autoload_y; +// +uint8_t fsensor_autoload_c; +// +uint32_t fsensor_autoload_last_millis; +// +uint8_t fsensor_autoload_sum; +//! @} +#endif + + +//! @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 +ClFsensorPCB oFsensorPCB; +ClFsensorActionNA oFsensorActionNA; +bool bIRsensorStateFlag=false; +ShortTimer tIRsensorCheckTimer; +#endif //IR_SENSOR_ANALOG + +void fsensor_stop_and_save_print(void) +{ + puts_P(PSTR("fsensor_stop_and_save_print")); + stop_and_save_print_to_ram(0, 0); + fsensor_watch_runout = false; +} + +#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 + + +void fsensor_restore_print_and_continue(void) +{ + puts_P(PSTR("fsensor_restore_print_and_continue")); + fsensor_watch_runout = true; +#ifdef PAT9125 + fsensor_reset_err_cnt(); +#endif + restore_print_from_ram_and_continue(0); +} + +// 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 + +#ifndef IR_SENSOR + ir_sensor_detected = check_for_ir_sensor(); +#endif +} + +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_IR_check()) + { + 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 (IRSensorDetected()) { + 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 || IRSensorDetected()) 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 && IRSensorDetected()) + { + if (READ(IR_SENSOR_PIN)) + { // IR_SENSOR_PIN ~ H +#ifdef IR_SENSOR_ANALOG + if(!bIRsensorStateFlag) + { + bIRsensorStateFlag=true; + tIRsensorCheckTimer.start(); + } + else + { + if(tIRsensorCheckTimer.expired(IR_SENSOR_STEADY)) + { + uint8_t nMUX1,nMUX2; + uint16_t nADC; + bIRsensorStateFlag=false; + // sequence for direct data reading from AD converter + DISABLE_TEMPERATURE_INTERRUPT(); + nMUX1=ADMUX; // ADMUX saving + nMUX2=ADCSRB; + adc_setmux(VOLT_IR_PIN); + ADCSRA|=(1<4.6V + // If it does, it means a disconnected cables or faulty board + if( (oFsensorPCB == ClFsensorPCB::_Rev04) && ( (nADC*OVERSAMPLENR) > IRsensor_Hopen_TRESHOLD ) ) + { + fsensor_disable(); + fsensor_not_responding = true; + printf_P(PSTR("IR sensor not responding (%d)!\n"),1); + if((ClFsensorActionNA)eeprom_read_byte((uint8_t*)EEPROM_FSENSOR_ACTION_NA)==ClFsensorActionNA::_Pause) + + // if we are printing and FS action is set to "Pause", force pause the print + if(oFsensorActionNA==ClFsensorActionNA::_Pause) + lcd_pause_print(); + } + else + { +#endif //IR_SENSOR_ANALOG + fsensor_checkpoint_print(); + fsensor_enque_M600(); +#ifdef IR_SENSOR_ANALOG + } + } + } + } + else + { // IR_SENSOR_PIN ~ L + bIRsensorStateFlag=false; +#endif //IR_SENSOR_ANALOG + } + } +#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(){ + if( IRsensor_Lmax_TRESHOLD <= current_voltage_raw_IR && current_voltage_raw_IR <= 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 <= current_voltage_raw_IR && current_voltage_raw_IR <= 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 <= current_voltage_raw_IR && current_voltage_raw_IR <= 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) && ( current_voltage_raw_IR > 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 + +/// if IR_SENSOR is NOT defined, it tries to locate it. +/// @returns true if idler IR sensor was detected, otherwise returns false +#ifndef IR_SENSOR +bool check_for_ir_sensor() { + bool detected = false; + // if IR_SENSOR_PIN input is low and pat9125sensor is not present we detected idler sensor + if ((READ(IR_SENSOR_PIN) == 0) +#ifdef PAT9125 + && fsensor_not_responding +#endif // PAT9125 + ) { + detected = true; + // printf_P(PSTR("Idler IR sensor detected\n")); + } else { + // printf_P(PSTR("Idler IR sensor not detected\n")); + } + return detected; +} +#endif // IR_SENSOR diff --git a/Firmware/fsensor.h b/Firmware/fsensor.h new file mode 100755 index 000000000..83647a7d1 --- /dev/null +++ b/Firmware/fsensor.h @@ -0,0 +1,133 @@ +//! @file +#ifndef FSENSOR_H +#define FSENSOR_H + +#include +#include "config.h" + + +// enable/disable flag +extern bool fsensor_enabled; +// not responding flag +extern bool fsensor_not_responding; +#ifdef PAT9125 +// optical checking "chunk lenght" (already in steps) +extern int16_t fsensor_chunk_len; +// count of soft failures +extern uint8_t fsensor_softfail; +#endif + +//! @name save restore printing +//! @{ +extern void fsensor_stop_and_save_print(void); +//! restore print - restore position and heatup to original temperature +extern void fsensor_restore_print_and_continue(void); +//! split the current gcode stream to insert new instructions +extern void fsensor_checkpoint_print(void); +//! @} + +//! initialize +extern void fsensor_init(void); + +/// IR sensor detection originally for MMU? +/// Note: the signature of this function intentionally differs upon IR_SENSOR macro to allow for best optimization. +#ifdef IR_SENSOR +constexpr bool IRSensorDetected() { return true; } +#else +bool IRSensorDetected(); +#endif + + +#ifdef PAT9125 +//! update axis resolution +extern void fsensor_set_axis_steps_per_unit(float u); +#endif + +//! @name enable/disable +//! @{ +extern bool fsensor_enable(bool bUpdateEEPROM=true); +extern void fsensor_disable(bool bUpdateEEPROM=true); +//! @} + +//autoload feature enabled +extern bool fsensor_autoload_enabled; +extern void fsensor_autoload_set(bool State); + +extern void fsensor_update(void); +#ifdef PAT9125 +//! setup pin-change interrupt +extern void fsensor_setup_interrupt(void); + +//! @name autoload support +//! @{ + +extern void fsensor_autoload_check_start(void); +extern void fsensor_autoload_check_stop(void); +#endif //PAT9125 +extern bool fsensor_check_autoload(void); +//! @} + +#ifdef PAT9125 +//! @name optical quality measurement support +//! @{ +extern bool fsensor_oq_meassure_enabled; +extern void fsensor_oq_meassure_set(bool State); +extern void fsensor_oq_meassure_start(uint8_t skip); +extern void fsensor_oq_meassure_stop(void); +extern bool fsensor_oq_result(void); +//! @} + +//! @name callbacks from stepper +//! @{ +extern void fsensor_st_block_chunk(int cnt); + +// debugging +extern uint8_t fsensor_log; + +// There's really nothing to do in block_begin: the stepper ISR likely has +// called us already at the end of the last block, making this integration +// redundant. LA1.5 might not always do that during a coasting move, so attempt +// to drain fsensor_st_cnt anyway at the beginning of the new block. +#define fsensor_st_block_begin(rev) fsensor_st_block_chunk(0) +//! @} +#endif //PAT9125 + +#define VOLT_DIV_REF 5 + +#ifdef IR_SENSOR_ANALOG +#define IR_SENSOR_STEADY 10 // [ms] + +enum class ClFsensorPCB:uint_least8_t +{ + _Old=0, + _Rev04=1, + _Undef=EEPROM_EMPTY_VALUE +}; + +enum class ClFsensorActionNA:uint_least8_t +{ + _Continue=0, + _Pause=1, + _Undef=EEPROM_EMPTY_VALUE +}; + +extern ClFsensorPCB oFsensorPCB; +extern ClFsensorActionNA oFsensorActionNA; +extern const char* FsensorIRVersionText(); + +extern bool fsensor_IR_check(); +constexpr uint16_t Voltage2Raw(float V){ + return ( V * 1023 * OVERSAMPLENR / VOLT_DIV_REF ) + 0.5F; +} +constexpr float Raw2Voltage(uint16_t raw){ + return VOLT_DIV_REF*(raw / (1023.F * OVERSAMPLENR) ); +} +constexpr uint16_t IRsensor_Ldiode_TRESHOLD = Voltage2Raw(0.3F); // ~0.3V, raw value=982 +constexpr uint16_t IRsensor_Lmax_TRESHOLD = Voltage2Raw(1.5F); // ~1.5V (0.3*Vcc), raw value=4910 +constexpr uint16_t IRsensor_Hmin_TRESHOLD = Voltage2Raw(3.0F); // ~3.0V (0.6*Vcc), raw value=9821 +constexpr uint16_t IRsensor_Hopen_TRESHOLD = Voltage2Raw(4.6F); // ~4.6V (N.C. @ Ru~20-50k, Rd'=56k, Ru'=10k), raw value=15059 +constexpr uint16_t IRsensor_VMax_TRESHOLD = Voltage2Raw(5.F); // ~5V, raw value=16368 + +#endif //IR_SENSOR_ANALOG + +#endif //FSENSOR_H diff --git a/Firmware/mmu2_progress_converter.cpp b/Firmware/mmu2_progress_converter.cpp index aefe3f731..c9d37e5e7 100644 --- a/Firmware/mmu2_progress_converter.cpp +++ b/Firmware/mmu2_progress_converter.cpp @@ -3,4 +3,4 @@ namespace MMU2 { //@@TODO void TranslateProgress(uint16_t pc, char *dst, size_t dstSize) { } -} +} // namespace MMU2 diff --git a/Firmware/mmu2_protocol_logic.cpp b/Firmware/mmu2_protocol_logic.cpp index 3dde6fae7..5dd9fee05 100644 --- a/Firmware/mmu2_protocol_logic.cpp +++ b/Firmware/mmu2_protocol_logic.cpp @@ -47,7 +47,6 @@ void ProtocolLogicPartBase::SendButton(uint8_t btn){ StepStatus ProtocolLogic::ProcessUARTByte(uint8_t c) { switch (protocol.DecodeResponse(c)) { case DecodeStatus::MessageCompleted: - // @@TODO reset direction of communication return MessageReady; case DecodeStatus::NeedMoreData: return Processing; @@ -69,7 +68,6 @@ StepStatus ProtocolLogic::ExpectingMessage(uint32_t timeout) { case DecodeStatus::MessageCompleted: rsp = protocol.GetResponseMsg(); LogResponse(); - // @@TODO reset direction of communication RecordUARTActivity(); // something has happened on the UART, update the timeout record return MessageReady; case DecodeStatus::NeedMoreData: diff --git a/Firmware/mmu2_serial.h b/Firmware/mmu2_serial.h index 61949284c..176a8f336 100644 --- a/Firmware/mmu2_serial.h +++ b/Firmware/mmu2_serial.h @@ -8,7 +8,6 @@ namespace MMU2 { class MMU2Serial { public: MMU2Serial() = default; -// bool available()const; void begin(uint32_t baud); void close(); int read();