mmu2.cpp 36 KB

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