mmu2.cpp 33 KB

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