mmu2.cpp 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926
  1. #include "mmu2.h"
  2. #include "mmu2_error_converter.h"
  3. #include "mmu2_fsensor.h"
  4. #include "mmu2_log.h"
  5. #include "mmu2_power.h"
  6. #include "mmu2_progress_converter.h"
  7. #include "mmu2_reporting.h"
  8. #include "Marlin.h"
  9. #include "language.h"
  10. #include "messages.h"
  11. #include "sound.h"
  12. #include "stepper.h"
  13. #include "strlen_cx.h"
  14. #include "temperature.h"
  15. #include "ultralcd.h"
  16. #include "cardreader.h" // for IS_SD_PRINTING
  17. #include "SpoolJoin.h"
  18. // As of FW 3.12 we only support building the FW with only one extruder, all the multi-extruder infrastructure will be removed.
  19. // Saves at least 800B of code size
  20. static_assert(EXTRUDERS==1);
  21. // Settings for filament load / unload from the LCD menu.
  22. // This is for Prusa MK3-style extruders. Customize for your hardware.
  23. #define MMU2_FILAMENTCHANGE_EJECT_FEED 80.0
  24. #define NOZZLE_PARK_XY_FEEDRATE 50
  25. #define NOZZLE_PARK_Z_FEEDRATE 15
  26. // Nominal distance from the extruder gear to the nozzle tip is 87mm
  27. // However, some slipping may occur and we need separate distances for
  28. // LoadToNozzle and ToolChange.
  29. // - +5mm seemed good for LoadToNozzle,
  30. // - but too much (made blobs) for a ToolChange
  31. static constexpr float MMU2_LOAD_TO_NOZZLE_LENGTH = 87.0F + 5.0F;
  32. // As discussed with our PrusaSlicer profile specialist
  33. // - ToolChange shall not try to push filament into the very tip of the nozzle
  34. // to have some space for additional G-code to tune the extruded filament length
  35. // in the profile
  36. static constexpr float MMU2_TOOL_CHANGE_LOAD_LENGTH = 30.0F;
  37. static constexpr float MMU2_LOAD_TO_NOZZLE_FEED_RATE = 20.0F; // mm/s
  38. static constexpr float MMU2_UNLOAD_TO_FINDA_FEED_RATE = 120.0F; // mm/s
  39. // The first the MMU does is initialise its axis. Meanwhile the E-motor will unload 20mm of filament in approx. 1 second.
  40. static constexpr float MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH = 20.0f; // mm
  41. static constexpr float MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE = 20.0f; // mm/s
  42. static constexpr uint8_t MMU2_NO_TOOL = 99;
  43. static constexpr uint32_t MMU_BAUD = 115200;
  44. struct E_Step {
  45. float extrude; ///< extrude distance in mm
  46. float feedRate; ///< feed rate in mm/s
  47. };
  48. static constexpr E_Step ramming_sequence[] PROGMEM = {
  49. { 0.2816F, 1339.0F / 60.F},
  50. { 0.3051F, 1451.0F / 60.F},
  51. { 0.3453F, 1642.0F / 60.F},
  52. { 0.3990F, 1897.0F / 60.F},
  53. { 0.4761F, 2264.0F / 60.F},
  54. { 0.5767F, 2742.0F / 60.F},
  55. { 0.5691F, 3220.0F / 60.F},
  56. { 0.1081F, 3220.0F / 60.F},
  57. { 0.7644F, 3635.0F / 60.F},
  58. { 0.8248F, 3921.0F / 60.F},
  59. { 0.8483F, 4033.0F / 60.F},
  60. { -15.0F, 6000.0F / 60.F},
  61. { -24.5F, 1200.0F / 60.F},
  62. { -7.0F, 600.0F / 60.F},
  63. { -3.5F, 360.0F / 60.F},
  64. { 20.0F, 454.0F / 60.F},
  65. { -20.0F, 303.0F / 60.F},
  66. { -35.0F, 2000.0F / 60.F},
  67. };
  68. static constexpr E_Step load_to_nozzle_sequence[] PROGMEM = {
  69. { 10.0F, 810.0F / 60.F}, // feed rate = 13.5mm/s - Load fast until filament reach end of nozzle
  70. { 25.0F, 198.0F / 60.F}, // feed rate = 3.3mm/s - Load slower once filament is out of the nozzle
  71. };
  72. namespace MMU2 {
  73. void execute_extruder_sequence(const E_Step *sequence, int steps);
  74. template<typename F>
  75. void waitForHotendTargetTemp(uint16_t delay, F f){
  76. while (((degTargetHotend(active_extruder) - degHotend(active_extruder)) > 5)) {
  77. f();
  78. delay_keep_alive(delay);
  79. }
  80. }
  81. void WaitForHotendTargetTempBeep(){
  82. waitForHotendTargetTemp(3000, []{ Sound_MakeSound(e_SOUND_TYPE_StandardPrompt); } );
  83. }
  84. MMU2 mmu2;
  85. MMU2::MMU2()
  86. : is_mmu_error_monitor_active(false)
  87. , logic(&mmu2Serial)
  88. , extruder(MMU2_NO_TOOL)
  89. , tool_change_extruder(MMU2_NO_TOOL)
  90. , resume_position()
  91. , resume_hotend_temp(0)
  92. , logicStepLastStatus(StepStatus::Finished)
  93. , state(xState::Stopped)
  94. , mmu_print_saved(SavedState::None)
  95. , loadFilamentStarted(false)
  96. , unloadFilamentStarted(false)
  97. , loadingToNozzle(false)
  98. , inAutoRetry(false)
  99. , retryAttempts(MAX_RETRIES)
  100. {
  101. }
  102. void MMU2::Start() {
  103. #ifdef MMU_HWRESET
  104. WRITE(MMU_RST_PIN, 1);
  105. SET_OUTPUT(MMU_RST_PIN); // setup reset pin
  106. #endif //MMU_HWRESET
  107. mmu2Serial.begin(MMU_BAUD);
  108. PowerOn(); // I repurposed this to serve as our EEPROM disable toggle.
  109. Reset(ResetForm::ResetPin);
  110. mmu2Serial.flush(); // make sure the UART buffer is clear before starting communication
  111. extruder = MMU2_NO_TOOL;
  112. state = xState::Connecting;
  113. // start the communication
  114. logic.Start();
  115. ResetRetryAttempts();
  116. }
  117. void MMU2::Stop() {
  118. StopKeepPowered();
  119. PowerOff(); // This also disables the MMU in the EEPROM.
  120. }
  121. void MMU2::StopKeepPowered(){
  122. state = xState::Stopped;
  123. logic.Stop();
  124. mmu2Serial.close();
  125. }
  126. void MMU2::Reset(ResetForm level){
  127. switch (level) {
  128. case Software: ResetX0(); break;
  129. case ResetPin: TriggerResetPin(); break;
  130. case CutThePower: PowerCycle(); break;
  131. default: break;
  132. }
  133. }
  134. void MMU2::ResetX0() {
  135. logic.ResetMMU(); // Send soft reset
  136. }
  137. void MMU2::TriggerResetPin(){
  138. reset();
  139. }
  140. void MMU2::PowerCycle(){
  141. // cut the power to the MMU and after a while restore it
  142. // Sadly, MK3/S/+ cannot do this
  143. // NOTE: the below will toggle the EEPROM var. Should we
  144. // assert this function is never called in the MK3 FW? Do we even care?
  145. PowerOff();
  146. delay_keep_alive(1000);
  147. PowerOn();
  148. }
  149. void MMU2::PowerOff(){
  150. power_off();
  151. }
  152. void MMU2::PowerOn(){
  153. power_on();
  154. }
  155. bool MMU2::ReadRegister(uint8_t address){
  156. if( ! WaitForMMUReady())
  157. return false;
  158. logic.ReadRegister(address); // we may signal the accepted/rejected status of the response as return value of this function
  159. manage_response(false, false);
  160. return true;
  161. }
  162. bool MMU2::WriteRegister(uint8_t address, uint16_t data){
  163. if( ! WaitForMMUReady())
  164. return false;
  165. logic.WriteRegister(address, data); // we may signal the accepted/rejected status of the response as return value of this function
  166. manage_response(false, false);
  167. return true;
  168. }
  169. void MMU2::mmu_loop() {
  170. // We only leave this method if the current command was successfully completed - that's the Marlin's way of blocking operation
  171. // Atomic compare_exchange would have been the most appropriate solution here, but this gets called only in Marlin's task,
  172. // so thread safety should be kept
  173. static bool avoidRecursion = false;
  174. if (avoidRecursion)
  175. return;
  176. avoidRecursion = true;
  177. logicStepLastStatus = LogicStep(); // it looks like the mmu_loop doesn't need to be a blocking call
  178. if (is_mmu_error_monitor_active){
  179. // Call this every iteration to keep the knob rotation responsive
  180. // This includes when mmu_loop is called within manage_response
  181. ReportErrorHook((uint16_t)lastErrorCode, mmu2.MMUCurrentErrorCode() == ErrorCode::OK ? ErrorSourcePrinter : ErrorSourceMMU);
  182. }
  183. avoidRecursion = false;
  184. }
  185. void MMU2::CheckFINDARunout()
  186. {
  187. // Check for FINDA filament runout
  188. if (!FindaDetectsFilament() && CHECK_FSENSOR) {
  189. SERIAL_ECHOLNPGM("FINDA filament runout!");
  190. stop_and_save_print_to_ram(0, 0);
  191. restore_print_from_ram_and_continue(0);
  192. if (SpoolJoin::spooljoin.isSpoolJoinEnabled() && get_current_tool() != (uint8_t)FILAMENT_UNKNOWN) // Can't auto if F=?
  193. {
  194. enquecommand_front_P(PSTR("M600 AUTO")); //save print and run M600 command
  195. }
  196. else
  197. {
  198. enquecommand_front_P(PSTR("M600")); //save print and run M600 command
  199. }
  200. }
  201. }
  202. struct ReportingRAII {
  203. CommandInProgress cip;
  204. inline ReportingRAII(CommandInProgress cip):cip(cip){
  205. BeginReport(cip, (uint16_t)ProgressCode::EngagingIdler);
  206. }
  207. inline ~ReportingRAII(){
  208. EndReport(cip, (uint16_t)ProgressCode::OK);
  209. }
  210. };
  211. bool MMU2::WaitForMMUReady(){
  212. switch(State()){
  213. case xState::Stopped:
  214. return false;
  215. case xState::Connecting:
  216. // shall we wait until the MMU reconnects?
  217. // fire-up a fsm_dlg and show "MMU not responding"?
  218. default:
  219. return true;
  220. }
  221. }
  222. bool MMU2::RetryIfPossible(uint16_t ec){
  223. if( retryAttempts ){
  224. SERIAL_ECHOPGM("retryAttempts=");SERIAL_ECHOLN((uint16_t)retryAttempts);
  225. SetButtonResponse(ButtonOperations::Retry);
  226. // check, that Retry is actually allowed on that operation
  227. if( ButtonAvailable(ec) != NoButton ){
  228. inAutoRetry = true;
  229. SERIAL_ECHOLNPGM("RetryButtonPressed");
  230. // We don't decrement until the button is acknowledged by the MMU.
  231. //--retryAttempts; // "used" one retry attempt
  232. return true;
  233. }
  234. }
  235. inAutoRetry = false;
  236. return false;
  237. }
  238. void MMU2::ResetRetryAttempts(){
  239. SERIAL_ECHOLNPGM("ResetRetryAttempts");
  240. retryAttempts = MAX_RETRIES;
  241. }
  242. void MMU2::DecrementRetryAttempts(){
  243. if (inAutoRetry && retryAttempts)
  244. {
  245. SERIAL_ECHOLNPGM("DecrementRetryAttempts");
  246. retryAttempts--;
  247. }
  248. }
  249. bool MMU2::tool_change(uint8_t index) {
  250. if( ! WaitForMMUReady())
  251. return false;
  252. if (index != extruder) {
  253. if (!IS_SD_PRINTING && !usb_timer.running())
  254. {
  255. // If Tcodes are used manually through the serial
  256. // we need to unload manually as well
  257. unload();
  258. }
  259. ReportingRAII rep(CommandInProgress::ToolChange);
  260. FSensorBlockRunout blockRunout;
  261. st_synchronize();
  262. tool_change_extruder = index;
  263. logic.ToolChange(index); // let the MMU pull the filament out and push a new one in
  264. manage_response(true, true);
  265. // reset current position to whatever the planner thinks it is
  266. plan_set_e_position(current_position[E_AXIS]);
  267. extruder = index; //filament change is finished
  268. SpoolJoin::spooljoin.setSlot(index);
  269. // @@TODO really report onto the serial? May be for the Octoprint? Not important now
  270. // SERIAL_ECHO_START();
  271. // SERIAL_ECHOLNPAIR(MSG_ACTIVE_EXTRUDER, int(extruder));
  272. }
  273. return true;
  274. }
  275. /// Handle special T?/Tx/Tc commands
  276. ///
  277. ///- T? Gcode to extrude shouldn't have to follow, load to extruder wheels is done automatically
  278. ///- Tx Same as T?, except nozzle doesn't have to be preheated. Tc must be placed after extruder nozzle is preheated to finish filament load.
  279. ///- Tc Load to nozzle after filament was prepared by Tx and extruder nozzle is already heated.
  280. bool MMU2::tool_change(char code, uint8_t slot) {
  281. if( ! WaitForMMUReady())
  282. return false;
  283. FSensorBlockRunout blockRunout;
  284. switch (code) {
  285. case '?': {
  286. waitForHotendTargetTemp(100, []{});
  287. load_filament_to_nozzle(slot);
  288. } break;
  289. case 'x': {
  290. set_extrude_min_temp(0); // Allow cold extrusion since Tx only loads to the gears not nozzle
  291. st_synchronize();
  292. tool_change_extruder = slot;
  293. logic.ToolChange(slot);
  294. manage_response(false, false);
  295. extruder = slot;
  296. SpoolJoin::spooljoin.setSlot(slot);
  297. set_extrude_min_temp(EXTRUDE_MINTEMP);
  298. } break;
  299. case 'c': {
  300. waitForHotendTargetTemp(100, []{});
  301. execute_extruder_sequence((const E_Step *)load_to_nozzle_sequence, sizeof(load_to_nozzle_sequence) / sizeof (load_to_nozzle_sequence[0]));
  302. } break;
  303. }
  304. return true;
  305. }
  306. void MMU2::get_statistics() {
  307. logic.Statistics();
  308. }
  309. uint8_t MMU2::get_current_tool() const {
  310. return extruder == MMU2_NO_TOOL ? (uint8_t)FILAMENT_UNKNOWN : extruder;
  311. }
  312. uint8_t MMU2::get_tool_change_tool() const {
  313. return tool_change_extruder == MMU2_NO_TOOL ? (uint8_t)FILAMENT_UNKNOWN : tool_change_extruder;
  314. }
  315. bool MMU2::set_filament_type(uint8_t index, uint8_t type) {
  316. if( ! WaitForMMUReady())
  317. return false;
  318. // @@TODO - this is not supported in the new MMU yet
  319. // cmd_arg = filamentType;
  320. // command(MMU_CMD_F0 + index);
  321. manage_response(false, false); // true, true); -- Comment: how is it possible for a filament type set to fail?
  322. return true;
  323. }
  324. bool MMU2::unload() {
  325. if( ! WaitForMMUReady())
  326. return false;
  327. WaitForHotendTargetTempBeep();
  328. {
  329. FSensorBlockRunout blockRunout;
  330. ReportingRAII rep(CommandInProgress::UnloadFilament);
  331. filament_ramming();
  332. logic.UnloadFilament();
  333. manage_response(false, true);
  334. Sound_MakeSound(e_SOUND_TYPE_StandardConfirm);
  335. // no active tool
  336. extruder = MMU2_NO_TOOL;
  337. tool_change_extruder = MMU2_NO_TOOL;
  338. }
  339. return true;
  340. }
  341. bool MMU2::cut_filament(uint8_t index){
  342. if( ! WaitForMMUReady())
  343. return false;
  344. ReportingRAII rep(CommandInProgress::CutFilament);
  345. logic.CutFilament(index);
  346. manage_response(false, true);
  347. return true;
  348. }
  349. void FullScreenMsg(const char *pgmS, uint8_t slot){
  350. lcd_update_enable(false);
  351. lcd_clear();
  352. lcd_puts_at_P(0, 1, pgmS);
  353. lcd_print(' ');
  354. lcd_print(slot + 1);
  355. }
  356. bool MMU2::load_to_extruder(uint8_t index){
  357. FullScreenMsg(_T(MSG_TESTING_FILAMENT), index);
  358. tool_change(index);
  359. st_synchronize();
  360. unload();
  361. lcd_update_enable(true);
  362. return true;
  363. }
  364. bool MMU2::load_filament(uint8_t index) {
  365. if( ! WaitForMMUReady())
  366. return false;
  367. FullScreenMsg(_T(MSG_LOADING_FILAMENT), index);
  368. ReportingRAII rep(CommandInProgress::LoadFilament);
  369. logic.LoadFilament(index);
  370. manage_response(false, false);
  371. Sound_MakeSound(e_SOUND_TYPE_StandardConfirm);
  372. lcd_update_enable(true);
  373. return true;
  374. }
  375. struct LoadingToNozzleRAII {
  376. MMU2 &mmu2;
  377. explicit inline LoadingToNozzleRAII(MMU2 &mmu2):mmu2(mmu2){
  378. mmu2.loadingToNozzle = true;
  379. }
  380. inline ~LoadingToNozzleRAII(){
  381. mmu2.loadingToNozzle = false;
  382. }
  383. };
  384. bool MMU2::load_filament_to_nozzle(uint8_t index) {
  385. if( ! WaitForMMUReady())
  386. return false;
  387. LoadingToNozzleRAII ln(*this);
  388. WaitForHotendTargetTempBeep();
  389. FullScreenMsg(_T(MSG_LOADING_FILAMENT), index);
  390. {
  391. // used for MMU-menu operation "Load to Nozzle"
  392. ReportingRAII rep(CommandInProgress::ToolChange);
  393. FSensorBlockRunout blockRunout;
  394. if( extruder != MMU2_NO_TOOL ){ // we already have some filament loaded - free it + shape its tip properly
  395. filament_ramming();
  396. }
  397. tool_change_extruder = index;
  398. logic.ToolChange(index);
  399. manage_response(true, true);
  400. // The MMU's idler is disengaged at this point
  401. // That means the MK3/S now has fully control
  402. // reset current position to whatever the planner thinks it is
  403. st_synchronize();
  404. plan_set_e_position(current_position[E_AXIS]);
  405. // Finish loading to the nozzle with finely tuned steps.
  406. execute_extruder_sequence((const E_Step *)load_to_nozzle_sequence, sizeof(load_to_nozzle_sequence) / sizeof (load_to_nozzle_sequence[0]));
  407. extruder = index;
  408. SpoolJoin::spooljoin.setSlot(index);
  409. Sound_MakeSound(e_SOUND_TYPE_StandardConfirm);
  410. }
  411. lcd_update_enable(true);
  412. return true;
  413. }
  414. bool MMU2::eject_filament(uint8_t index, bool recover) {
  415. if( ! WaitForMMUReady())
  416. return false;
  417. ReportingRAII rep(CommandInProgress::EjectFilament);
  418. current_position[E_AXIS] -= MMU2_FILAMENTCHANGE_EJECT_FEED;
  419. plan_buffer_line_curposXYZE(2500.F / 60.F);
  420. st_synchronize();
  421. logic.EjectFilament(index);
  422. manage_response(false, false);
  423. if (recover) {
  424. // LCD_MESSAGEPGM(MSG_MMU2_EJECT_RECOVER);
  425. Sound_MakeSound(e_SOUND_TYPE_StandardPrompt);
  426. //@@TODO wait_for_user = true;
  427. //#if ENABLED(HOST_PROMPT_SUPPORT)
  428. // host_prompt_do(PROMPT_USER_CONTINUE, PSTR("MMU2 Eject Recover"), PSTR("Continue"));
  429. //#endif
  430. //#if ENABLED(EXTENSIBLE_UI)
  431. // ExtUI::onUserConfirmRequired_P(PSTR("MMU2 Eject Recover"));
  432. //#endif
  433. //@@TODO while (wait_for_user) idle(true);
  434. Sound_MakeSound(e_SOUND_TYPE_StandardConfirm);
  435. // logic.Command(); //@@TODO command(MMU_CMD_R0);
  436. manage_response(false, false);
  437. }
  438. // no active tool
  439. extruder = MMU2_NO_TOOL;
  440. tool_change_extruder = MMU2_NO_TOOL;
  441. Sound_MakeSound(e_SOUND_TYPE_StandardConfirm);
  442. // disable_E0();
  443. return true;
  444. }
  445. void MMU2::Button(uint8_t index){
  446. LogEchoEvent_P(PSTR("Button"));
  447. logic.Button(index);
  448. }
  449. void MMU2::Home(uint8_t mode){
  450. logic.Home(mode);
  451. }
  452. void MMU2::SaveAndPark(bool move_axes, bool turn_off_nozzle) {
  453. if (mmu_print_saved == SavedState::None) { // First occurrence. Save current position, park print head, disable nozzle heater.
  454. LogEchoEvent_P(PSTR("Saving and parking"));
  455. st_synchronize();
  456. resume_hotend_temp = degTargetHotend(active_extruder);
  457. if (move_axes){
  458. mmu_print_saved |= SavedState::ParkExtruder;
  459. // save current pos
  460. for(uint8_t i = 0; i < 3; ++i){
  461. resume_position.xyz[i] = current_position[i];
  462. }
  463. // lift Z
  464. raise_z(MMU_ERR_Z_PAUSE_LIFT);
  465. // move XY aside
  466. current_position[X_AXIS] = MMU_ERR_X_PAUSE_POS;
  467. current_position[Y_AXIS] = MMU_ERR_Y_PAUSE_POS;
  468. plan_buffer_line_curposXYZE(NOZZLE_PARK_XY_FEEDRATE);
  469. st_synchronize();
  470. }
  471. if (turn_off_nozzle){
  472. mmu_print_saved |= SavedState::CooldownPending;
  473. LogEchoEvent_P(PSTR("Heater cooldown pending"));
  474. // This just sets the flag that we should timeout and shut off the nozzle in 30 minutes...
  475. //setAllTargetHotends(0);
  476. }
  477. }
  478. // keep the motors powered forever (until some other strategy is chosen)
  479. // @@TODO do we need that in 8bit?
  480. // gcode.reset_stepper_timeout();
  481. }
  482. void MMU2::ResumeHotendTemp() {
  483. if ((mmu_print_saved & SavedState::CooldownPending))
  484. {
  485. // Clear the "pending" flag if we haven't cooled yet.
  486. mmu_print_saved &= ~(SavedState::CooldownPending);
  487. LogEchoEvent_P(PSTR("Cooldown flag cleared"));
  488. }
  489. if ((mmu_print_saved & SavedState::Cooldown) && resume_hotend_temp) {
  490. LogEchoEvent_P(PSTR("Resuming Temp"));
  491. MMU2_ECHO_MSGRPGM(PSTR("Restoring hotend temperature "));
  492. SERIAL_ECHOLN(resume_hotend_temp);
  493. mmu_print_saved &= ~(SavedState::Cooldown);
  494. setTargetHotend(resume_hotend_temp, active_extruder);
  495. lcd_display_message_fullscreen_P(_i("MMU Retry: Restoring temperature...")); ////MSG_MMU_RESTORE_TEMP c=20 r=4
  496. //@todo better report the event and let the GUI do its work somewhere else
  497. ReportErrorHookSensorLineRender();
  498. waitForHotendTargetTemp(1000, []{
  499. ReportErrorHookDynamicRender();
  500. manage_inactivity(true);
  501. });
  502. lcd_update_enable(true); // temporary hack to stop this locking the printer...
  503. LogEchoEvent_P(PSTR("Hotend temperature reached"));
  504. lcd_clear();
  505. }
  506. }
  507. void MMU2::ResumeUnpark(){
  508. if (mmu_print_saved & SavedState::ParkExtruder) {
  509. LogEchoEvent_P(PSTR("Resuming XYZ"));
  510. current_position[X_AXIS] = resume_position.xyz[X_AXIS];
  511. current_position[Y_AXIS] = resume_position.xyz[Y_AXIS];
  512. plan_buffer_line_curposXYZE(NOZZLE_PARK_XY_FEEDRATE);
  513. st_synchronize();
  514. current_position[Z_AXIS] = resume_position.xyz[Z_AXIS];
  515. plan_buffer_line_curposXYZE(NOZZLE_PARK_Z_FEEDRATE);
  516. st_synchronize();
  517. mmu_print_saved &= ~(SavedState::ParkExtruder);
  518. }
  519. }
  520. void MMU2::CheckUserInput(){
  521. auto btn = ButtonPressed((uint16_t)lastErrorCode);
  522. // Was a button pressed on the MMU itself instead of the LCD?
  523. if (btn == Buttons::NoButton && lastButton != Buttons::NoButton){
  524. btn = lastButton;
  525. lastButton = Buttons::NoButton; // Clear it.
  526. }
  527. switch (btn) {
  528. case Left:
  529. case Middle:
  530. case Right:
  531. SERIAL_ECHOPGM("CheckUserInput-btnLMR ");
  532. SERIAL_ECHOLN(btn);
  533. ResumeHotendTemp(); // Recover the hotend temp before we attempt to do anything else...
  534. Button(btn);
  535. break;
  536. case RestartMMU:
  537. Reset(ResetPin); // we cannot do power cycle on the MK3
  538. // ... but mmu2_power.cpp knows this and triggers a soft-reset instead.
  539. break;
  540. case DisableMMU:
  541. Stop(); // Poweroff handles updating the EEPROM shutoff.
  542. break;
  543. case StopPrint:
  544. // @@TODO not sure if we shall handle this high level operation at this spot
  545. break;
  546. default:
  547. break;
  548. }
  549. }
  550. /// Originally, this was used to wait for response and deal with timeout if necessary.
  551. /// The new protocol implementation enables much nicer and intense reporting, so this method will boil down
  552. /// just to verify the result of an issued command (which was basically the original idea)
  553. ///
  554. /// It is closely related to mmu_loop() (which corresponds to our ProtocolLogic::Step()), which does NOT perform any blocking wait for a command to finish.
  555. /// But - in case of an error, the command is not yet finished, but we must react accordingly - move the printhead elsewhere, stop heating, eat a cat or so.
  556. /// That's what's being done here...
  557. void MMU2::manage_response(const bool move_axes, const bool turn_off_nozzle) {
  558. mmu_print_saved = SavedState::None;
  559. KEEPALIVE_STATE(IN_PROCESS);
  560. LongTimer nozzleTimeout;
  561. for (;;) {
  562. // in our new implementation, we know the exact state of the MMU at any moment, we do not have to wait for a timeout
  563. // So in this case we shall decide if the operation is:
  564. // - still running -> wait normally in idle()
  565. // - failed -> then do the safety moves on the printer like before
  566. // - finished ok -> proceed with reading other commands
  567. manage_heater();
  568. manage_inactivity(true); // calls LogicStep() and remembers its return status
  569. lcd_update(0);
  570. if (mmu_print_saved & SavedState::CooldownPending){
  571. if (!nozzleTimeout.running()){
  572. nozzleTimeout.start();
  573. LogEchoEvent_P(PSTR("Cooling Timeout started"));
  574. } else if (nozzleTimeout.expired(DEFAULT_SAFETYTIMER_TIME_MINS*60*1000ul)){ // mins->msec. TODO: do we use the global or have our own independent timeout
  575. mmu_print_saved &= ~(SavedState::CooldownPending);
  576. mmu_print_saved |= SavedState::Cooldown;
  577. setAllTargetHotends(0);
  578. LogEchoEvent_P(PSTR("Heater cooldown"));
  579. }
  580. } else if (nozzleTimeout.running()) {
  581. nozzleTimeout.stop();
  582. LogEchoEvent_P(PSTR("Cooling timer stopped"));
  583. }
  584. switch (logicStepLastStatus) {
  585. case Finished:
  586. // command/operation completed, let Marlin continue its work
  587. // the E may have some more moves to finish - wait for them
  588. ResumeUnpark(); // We can now travel back to the tower or wherever we were when we saved.
  589. ResetRetryAttempts(); // Reset the retry counter.
  590. st_synchronize();
  591. return;
  592. case VersionMismatch: // this basically means the MMU will be disabled until reconnected
  593. CheckUserInput();
  594. return;
  595. case CommandError:
  596. // Don't proceed to the park/save if we are doing an autoretry.
  597. if (inAutoRetry){
  598. continue;
  599. }
  600. [[fallthrough]];
  601. case CommunicationTimeout:
  602. case ProtocolError:
  603. SaveAndPark(move_axes, turn_off_nozzle); // and wait for the user to resolve the problem
  604. CheckUserInput();
  605. break;
  606. case CommunicationRecovered: // @@TODO communication recovered and may be an error recovered as well
  607. // may be the logic layer can detect the change of state a respond with one "Recovered" to be handled here
  608. ResumeHotendTemp();
  609. ResumeUnpark();
  610. break;
  611. case Processing: // wait for the MMU to respond
  612. default:
  613. break;
  614. }
  615. }
  616. }
  617. StepStatus MMU2::LogicStep() {
  618. CheckUserInput(); // Process any buttons before proceeding with another MMU Query
  619. StepStatus ss = logic.Step();
  620. switch (ss) {
  621. case Finished:
  622. // At this point it is safe to trigger a runout and not interrupt the MMU protocol
  623. CheckFINDARunout();
  624. break;
  625. case Processing:
  626. OnMMUProgressMsg(logic.Progress());
  627. break;
  628. case CommandError:
  629. ReportError(logic.Error(), ErrorSourceMMU);
  630. break;
  631. case CommunicationTimeout:
  632. state = xState::Connecting;
  633. ReportError(ErrorCode::MMU_NOT_RESPONDING, ErrorSourcePrinter);
  634. break;
  635. case ProtocolError:
  636. state = xState::Connecting;
  637. ReportError(ErrorCode::PROTOCOL_ERROR, ErrorSourcePrinter);
  638. break;
  639. case VersionMismatch:
  640. StopKeepPowered();
  641. ReportError(ErrorCode::VERSION_MISMATCH, ErrorSourcePrinter);
  642. break;
  643. case ButtonPushed:
  644. lastButton = logic.Button();
  645. LogEchoEvent_P(PSTR("MMU Button pushed"));
  646. CheckUserInput(); // Process the button immediately
  647. break;
  648. default:
  649. break;
  650. }
  651. if( logic.Running() ){
  652. state = xState::Active;
  653. }
  654. return ss;
  655. }
  656. void MMU2::filament_ramming() {
  657. execute_extruder_sequence((const E_Step *)ramming_sequence, sizeof(ramming_sequence) / sizeof(E_Step));
  658. }
  659. void MMU2::execute_extruder_sequence(const E_Step *sequence, uint8_t steps) {
  660. st_synchronize();
  661. const E_Step *step = sequence;
  662. for (uint8_t i = 0; i < steps; i++) {
  663. current_position[E_AXIS] += pgm_read_float(&(step->extrude));
  664. plan_buffer_line_curposXYZE(pgm_read_float(&(step->feedRate)));
  665. st_synchronize();
  666. step++;
  667. }
  668. }
  669. void MMU2::ReportError(ErrorCode ec, uint8_t res) {
  670. // Due to a potential lossy error reporting layers linked to this hook
  671. // we'd better report everything to make sure especially the error states
  672. // do not get lost.
  673. // - The good news here is the fact, that the MMU reports the errors repeatedly until resolved.
  674. // - The bad news is, that MMU not responding may repeatedly occur on printers not having the MMU at all.
  675. //
  676. // Not sure how to properly handle this situation, options:
  677. // - skip reporting "MMU not responding" (at least for now)
  678. // - report only changes of states (we can miss an error message)
  679. // - may be some combination of MMUAvailable + UseMMU flags and decide based on their state
  680. // Right now the filtering of MMU_NOT_RESPONDING is done in ReportErrorHook() as it is not a problem if mmu2.cpp
  681. // Depending on the Progress code, we may want to do some action when an error occurs
  682. switch (logic.Progress()){
  683. case ProgressCode::UnloadingToFinda:
  684. unloadFilamentStarted = false;
  685. break;
  686. case ProgressCode::FeedingToFSensor:
  687. // FSENSOR error during load. Make sure E-motor stops moving.
  688. loadFilamentStarted = false;
  689. break;
  690. default:
  691. break;
  692. }
  693. ReportErrorHook((uint16_t)ec, res);
  694. if( ec != lastErrorCode ){ // deduplicate: only report changes in error codes into the log
  695. lastErrorCode = ec;
  696. LogErrorEvent_P( _O(PrusaErrorTitle(PrusaErrorCodeIndex((uint16_t)ec))) );
  697. }
  698. static_assert(mmu2Magic[0] == 'M'
  699. && mmu2Magic[1] == 'M'
  700. && mmu2Magic[2] == 'U'
  701. && mmu2Magic[3] == '2'
  702. && mmu2Magic[4] == ':'
  703. && strlen_constexpr(mmu2Magic) == 5,
  704. "MMU2 logging prefix mismatch, must be updated at various spots"
  705. );
  706. }
  707. void MMU2::ReportProgress(ProgressCode pc) {
  708. ReportProgressHook((CommandInProgress)logic.CommandInProgress(), (uint16_t)pc);
  709. LogEchoEvent_P( _O(ProgressCodeToText((uint16_t)pc)) );
  710. }
  711. void MMU2::OnMMUProgressMsg(ProgressCode pc){
  712. if (pc != lastProgressCode) {
  713. OnMMUProgressMsgChanged(pc);
  714. } else {
  715. OnMMUProgressMsgSame(pc);
  716. }
  717. }
  718. void MMU2::OnMMUProgressMsgChanged(ProgressCode pc){
  719. ReportProgress(pc);
  720. lastProgressCode = pc;
  721. switch (pc) {
  722. case ProgressCode::UnloadingToFinda:
  723. if ((CommandInProgress)logic.CommandInProgress() == CommandInProgress::UnloadFilament
  724. || ((CommandInProgress)logic.CommandInProgress() == CommandInProgress::ToolChange))
  725. {
  726. // If MK3S sent U0 command, ramming sequence takes care of releasing the filament.
  727. // If Toolchange is done while printing, PrusaSlicer takes care of releasing the filament
  728. // If printing is not in progress, ToolChange will issue a U0 command.
  729. break;
  730. } else {
  731. // We're likely recovering from an MMU error
  732. st_synchronize();
  733. unloadFilamentStarted = true;
  734. current_position[E_AXIS] -= MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH;
  735. plan_buffer_line_curposXYZE(MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE);
  736. }
  737. break;
  738. case ProgressCode::FeedingToFSensor:
  739. // prepare for the movement of the E-motor
  740. st_synchronize();
  741. loadFilamentStarted = true;
  742. break;
  743. default:
  744. // do nothing yet
  745. break;
  746. }
  747. }
  748. void MMU2::OnMMUProgressMsgSame(ProgressCode pc){
  749. switch (pc) {
  750. case ProgressCode::UnloadingToFinda:
  751. if (unloadFilamentStarted && !blocks_queued()) { // Only plan a move if there is no move ongoing
  752. if (fsensor.getFilamentPresent()) {
  753. current_position[E_AXIS] -= MMU2_RETRY_UNLOAD_TO_FINDA_LENGTH;
  754. plan_buffer_line_curposXYZE(MMU2_RETRY_UNLOAD_TO_FINDA_FEED_RATE);
  755. } else {
  756. unloadFilamentStarted = false;
  757. }
  758. }
  759. break;
  760. case ProgressCode::FeedingToFSensor:
  761. if (loadFilamentStarted) {
  762. switch (WhereIsFilament()) {
  763. case FilamentState::AT_FSENSOR:
  764. // fsensor triggered, finish FeedingToExtruder state
  765. loadFilamentStarted = false;
  766. // After the MMU knows the FSENSOR is triggered it will:
  767. // 1. Push the filament by additional 30mm (see fsensorToNozzle)
  768. // 2. Disengage the idler and push another 5mm.
  769. current_position[E_AXIS] += 30.0f + 2.0f;
  770. plan_buffer_line_curposXYZE(MMU2_LOAD_TO_NOZZLE_FEED_RATE);
  771. break;
  772. case FilamentState::NOT_PRESENT:
  773. // fsensor not triggered, continue moving extruder
  774. if (!blocks_queued()) { // Only plan a move if there is no move ongoing
  775. current_position[E_AXIS] += 2.0f;
  776. plan_buffer_line_curposXYZE(MMU2_LOAD_TO_NOZZLE_FEED_RATE);
  777. }
  778. break;
  779. default:
  780. // Abort here?
  781. break;
  782. }
  783. }
  784. break;
  785. default:
  786. // do nothing yet
  787. break;
  788. }
  789. }
  790. } // namespace MMU2